Lifecycle详解

jianning-wu

已于 2023-08-11 17:45:44 修改

阅读量1.2k

点赞数

分类专栏： Android Jetpack 文章标签： Android Jetpack jetpack Lifecycle Android 前后台切换 APP前后台切换判断

于 2018-10-23 16:35:43 首次发布

本文链接：https://blog.csdn.net/weixin_37730482/article/details/83309104

版权

Android Jetpack 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

本章节讲述Jetpack的组件Lifecycle的使用。

一.简介

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

二.Activity/Fragment基本使用

1.Gradle依赖

非androidX项目

implementation "android.arch.lifecycle:extensions:1.1.1"

AndroidX项目

implementation 'androidx.appcompat:appcompat:1.2.0'

这一行依赖，已经可以使用Jetpack的好多组件了，比如ViewModel，比如LiveData等等。当然也可以单个引入，具体见官方文档

Lifecycle | Android 开发者 | Android Developers

2.原理

Lifecycle的使用其实挺简单的。主要有两个步骤。

<1> Activity/Fragment生命周期拥有者使用getLifecycle()获取Lifecycle实例，然后使用addObserve()添加观察者。

<2> 自定义类实现LifecycleObserver接口，方法上使用OnLifecycleEvent的注解关注Activity/Fragment的生命周期方法，生命周期触发时就会执行对应方法。

3.代码

Activity

package com.wjn.rxdemo.lifecycle.activity;

import android.os.Bundle;
import android.util.Log;

import androidx.appcompat.app.AppCompatActivity;

import com.wjn.rxdemo.R;
import com.wjn.rxdemo.lifecycle.lifecycleobserver.ActivityLifecycleObserver;

public class LifeCycleActivity extends AppCompatActivity {

    private ActivityLifecycleObserver mActivityLifecycleObserver = new ActivityLifecycleObserver("LifeCycleActivity");

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_lifecycle);
        //获取Lifecycle生命周期 然后添加自定义的LifecycleObserver
        getLifecycle().addObserver(mActivityLifecycleObserver);
    }

    @Override
    protected void onStart() {
        super.onStart();
        Log.d("MyLifecycleObserver", "Activity的onStart方法 执行...");
    }

    @Override
    protected void onResume() {
        super.onResume();
        Log.d("MyLifecycleObserver", "Activity的onResume方法 执行...");
    }

    @Override
    protected void onStop() {
        super.onStop();
        Log.d("MyLifecycleObserver", "Activity的onStop方法 执行...");
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.d("MyLifecycleObserver", "Activity的onDestroy方法 执行...");
        //获取Lifecycle生命周期 然后移除自定义的LifecycleObserver
        getLifecycle().removeObserver(mActivityLifecycleObserver);
    }
}

LifecycleObserver的实现类

package com.wjn.rxdemo.lifecycle.lifecycleobserver;

import android.util.Log;

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

/**
 * LifecycleObserver的实现类
 */

public class ActivityLifecycleObserver implements LifecycleObserver {

    private String mActivityName;

    public ActivityLifecycleObserver(String activityName) {
        mActivityName = activityName;
    }

    /**
     * 监听Activity的onStart方法
     */
    @OnLifecycleEvent(value = Lifecycle.Event.ON_START)
    public void activityOnStart(LifecycleOwner owner) {
        Log.d("MyLifecycleObserver", "监听Activity的onStart方法 执行...owner：" + owner.getLifecycle().getCurrentState());
        Log.d("MyLifecycleObserver", "监听Activity的onStart方法 执行...ActivityName：" + mActivityName);
    }

    /**
     * 监听Activity的onResume方法
     */
    @OnLifecycleEvent(value = Lifecycle.Event.ON_RESUME)
    public void activityOnResume(LifecycleOwner owner) {
        Log.d("MyLifecycleObserver", "监听Activity的onResume方法 执行...owner：" + owner.getLifecycle().getCurrentState());
        Log.d("MyLifecycleObserver", "监听Activity的onResume方法 执行...ActivityName：" + mActivityName);
    }

    /**
     * 监听Activity的onStop方法
     */
    @OnLifecycleEvent(value = Lifecycle.Event.ON_STOP)
    public void activityOnStop(LifecycleOwner owner) {
        Log.d("MyLifecycleObserver", "监听Activity的onStop方法 执行...owner：" + owner.getLifecycle().getCurrentState());
        Log.d("MyLifecycleObserver", "监听Activity的onStop方法 执行...ActivityName：" + mActivityName);
    }

    /**
     * 监听Activity的onDestroy方法
     */
    @OnLifecycleEvent(value = Lifecycle.Event.ON_DESTROY)
    public void activityOnDestroy(LifecycleOwner owner) {
        Log.d("MyLifecycleObserver", "监听Activity的onDestroy方法 执行...owner：" + owner.getLifecycle().getCurrentState());
        Log.d("MyLifecycleObserver", "监听Activity的onDestroy方法 执行...ActivityName：" + mActivityName);
    }
}

结果

进入Activity

D/MyLifecycleObserver: Activity的onStart方法 执行...

D/MyLifecycleObserver: 监听Activity的onStart方法 执行...owner：STARTED

D/MyLifecycleObserver: 监听Activity的onStart方法 执行...ActivityName：LifeCycleActivity



D/MyLifecycleObserver: Activity的onResume方法 执行...

D/MyLifecycleObserver: 监听Activity的onResume方法 执行...owner：RESUMED

D/MyLifecycleObserver: 监听Activity的onResume方法 执行...ActivityName：LifeCycleActivity

销毁Activity (onStop方法的owner是CREATED)

D/MyLifecycleObserver: 监听Activity的onStop方法 执行...owner：CREATED

D/MyLifecycleObserver: 监听Activity的onStop方法 执行...ActivityName：LifeCycleActivity

D/MyLifecycleObserver: Activity的onStop方法 执行...



D/MyLifecycleObserver: 监听Activity的onDestroy方法 执行...owner：DESTROYED

D/MyLifecycleObserver: 监听Activity的onDestroy方法 执行...ActivityName：LifeCycleActivity

D/MyLifecycleObserver: Activity的onDestroy方法 执行...

Fragment

package com.wjn.rxdemo.lifecycle.fragment;

import android.os.Bundle;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

import androidx.fragment.app.Fragment;

import com.wjn.rxdemo.R;
import com.wjn.rxdemo.lifecycle.lifecycleobserver.FragmentLifecycleObserver;

public class LifeCycleFragment extends Fragment {

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //获取Lifecycle生命周期 然后添加自定义的LifecycleObserver
        getLifecycle().addObserver(new FragmentLifecycleObserver());
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        return inflater.inflate(R.layout.fragment_lifecycle, container, false);
    }

    @Override
    public void onStart() {
        super.onStart();
        Log.d("MyLifecycleObserver", "Fragment的onStart方法 执行...");
    }

    @Override
    public void onResume() {
        super.onResume();
        Log.d("MyLifecycleObserver", "Fragment的onResume方法 执行...");
    }

    @Override
    public void onStop() {
        super.onStop();
        Log.d("MyLifecycleObserver", "Fragment的onStop方法 执行...");
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.d("MyLifecycleObserver", "Fragment的onDestroy方法 执行...");
    }
}

LifecycleObserver的实现类

package com.wjn.rxdemo.lifecycle.lifecycleobserver;

import android.util.Log;

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

/**
 * LifecycleObserver的实现类
 */

public class FragmentLifecycleObserver implements LifecycleObserver {

    /**
     * 监听Fragment的onStart方法
     */
    @OnLifecycleEvent(value = Lifecycle.Event.ON_START)
    public void fragmentOnStart() {
        Log.d("MyLifecycleObserver", "监听Fragment的onStart方法 执行...");
    }

    /**
     * 监听Fragment的onResume方法
     */
    @OnLifecycleEvent(value = Lifecycle.Event.ON_RESUME)
    public void fragmentOnResume() {
        Log.d("MyLifecycleObserver", "监听Fragment的onResume方法 执行...");
    }

    /**
     * 监听Fragment的onStop方法
     */
    @OnLifecycleEvent(value = Lifecycle.Event.ON_STOP)
    public void fragmentOnStop() {
        Log.d("MyLifecycleObserver", "监听Fragment的onStop方法 执行...");
    }

    /**
     * 监听Fragment的onDestroy方法
     */
    @OnLifecycleEvent(value = Lifecycle.Event.ON_DESTROY)
    public void fragmentOnDestroy() {
        Log.d("MyLifecycleObserver", "监听Fragment的onDestroy方法 执行...");
    }

}

进入Fragment

D/MyLifecycleObserver: Fragment的onStart方法 执行...

D/MyLifecycleObserver: 监听Fragment的onStart方法 执行...owner：STARTED

D/MyLifecycleObserver: 监听Fragment的onStart方法 执行...FragmentName：LifeCycleFragment



D/MyLifecycleObserver: Fragment的onResume方法 执行...

D/MyLifecycleObserver: 监听Fragment的onResume方法 执行...owner：RESUMED

D/MyLifecycleObserver: 监听Fragment的onResume方法 执行...FragmentName：LifeCycleFragment

销毁Fragment (onStop方法的owner是CREATED)

D/MyLifecycleObserver: 监听Fragment的onStop方法 执行...owner：CREATED

D/MyLifecycleObserver: 监听Fragment的onStop方法 执行...FragmentName：LifeCycleFragment

D/MyLifecycleObserver: Fragment的onStop方法 执行...


D/MyLifecycleObserver: 监听Fragment的onDestroy方法 执行...owner：DESTROYED

D/MyLifecycleObserver: 监听Fragment的onDestroy方法 执行...FragmentName：LifeCycleFragment

D/MyLifecycleObserver: Fragment的onDestroy方法 执行...

4.说明

<1> 以上，就可以非常容易的将Activity/Fragment的生命周期方法抽离出来。这样Activity/Fragment中的逻辑就会少很多，也会变得很简洁。因为项目中可能一个Activity/Fragment的生命周期需要操作很多东西。比如

Activity的onStart+onResume+onPause+onStop四个方法。在使用百度地图，扫一扫，视频播放等等操作时，都需要在四个生命周期方法中做以下类似的操作

myLocationListener1.start();
myLocationListener2.start();
myLocationListener3.start();
...


myLocationListener1.resume();
myLocationListener2.resume();
myLocationListener3.resume();
...


myLocationListener1.stop();
myLocationListener2.stop();
myLocationListener3.stop();
...


myLocationListener1.destory();
myLocationListener2.destory();
myLocationListener3.destory();
...

<2> 有了这种方法，MVP中的Presenter层的请求方法开始以及停止请求(取消订阅)等等的方法，就可以不用写在Activity/Fragment中。而是写在自定义的LifecycleObserver接口实现类中的各个生命周期对应的注解方法中。这样Activity/Fragment中的代码就会很简洁。

<3> 除了上述使用到的onStart()方法，onResume()方法，onStop()方法，onDestory()方法等常用的生命周期方法外。还有几个注解的生命周期方法。

public enum Event {
        /**
         * Constant for onCreate event of the {@link LifecycleOwner}.
         */
        ON_CREATE,
        /**
         * Constant for onStart event of the {@link LifecycleOwner}.
         */
        ON_START,
        /**
         * Constant for onResume event of the {@link LifecycleOwner}.
         */
        ON_RESUME,
        /**
         * Constant for onPause event of the {@link LifecycleOwner}.
         */
        ON_PAUSE,
        /**
         * Constant for onStop event of the {@link LifecycleOwner}.
         */
        ON_STOP,
        /**
         * Constant for onDestroy event of the {@link LifecycleOwner}.
         */
        ON_DESTROY,
        /**
         * An {@link Event Event} constant that can be used to match all events.
         */
        ON_ANY;

...
}

<4> Activity/Fragment中之所以可以直接使用getLifecycle()方法获取Lifecycle对象。是因为Support Library 26.1.0及以上的Activity/Fragment和AndroidX的 Activity/Fragment 已实现 LifecycleOwner 接口。

Activity证明

public class LifeCycleActivity extends AppCompatActivity

public class AppCompatActivity extends FragmentActivity

public class FragmentActivity extends ComponentActivity

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        LifecycleOwner,
        ViewModelStoreOwner,
        SavedStateRegistryOwner,
        OnBackPressedDispatcherOwner

Fragment证明

public class LifeCycleFragment extends Fragment

public class Fragment implements ComponentCallbacks, OnCreateContextMenuListener, LifecycleOwner,ViewModelStoreOwner, SavedStateRegistryOwner

所以Activity/Fragment可以直接使用getLifecycle()方法获取Lifecycle对象。

<5> LifecycleObserver的实现类中。具体的注解得到的生命周期方法，也可以获取LifecycleOwner owner对象。有了LifecycleOwner owner对象。既可以在具体的生命周期方法中获取状态也可以继续添加其他的观察者。比如

/**
* 监听Activity的onStart方法
*/
@OnLifecycleEvent(value = Lifecycle.Event.ON_START)
public void activityOnStart(LifecycleOwner owner) {

    owner.getLifecycle().addObserver(anotherObserver);
   
}

<6> LifecycleObserver的实现类中。可以通过构造方法把Activity/Fragment的名称传过来，这样就可以多个Activity/Fragment公用一个LifecycleObserver的实现类。具体到每个Activity/Fragment有不同的逻辑时，可以使用名称判断处理不同的逻辑。

<7> 上述代码可知，添加观察者在onCreate方法中。但是要记住在onDestroy方法中将观察者移除。

三.自定义LifecycleOwner

上述可知，Support Library 26.1.0及以上的Activity/Fragment和AndroidX的 Activity/Fragment 已实现 LifecycleOwner 接口。所以这些Activity/Fragment可以直接使用直接使用getLifecycle()方法获取Lifecycle对象。然后添加/移除观察者。那么有一些普通的Activity/Fragment没有实现LifecycleOwner 接口。也想使用Lifecycle管理生命周期怎么办呢？下面以Activity为例

将上述的Activity

public class LifeCycleActivity extends AppCompatActivity

变成

public class LifeCycleActivity extends Activity

那么下面的代码直接使用就会报错

getLifecycle().addObserver(mActivityLifecycleObserver);

需要我们自己实现LifecycleOwner 接口。

代码

Activity

package com.wjn.rxdemo.lifecycle.activity;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;

import androidx.annotation.NonNull;
import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleOwner;
import androidx.lifecycle.LifecycleRegistry;

import com.wjn.rxdemo.R;
import com.wjn.rxdemo.lifecycle.lifecycleobserver.ActivityLifecycleObserver;

public class LifeCycleActivity extends Activity implements LifecycleOwner {

    private LifecycleRegistry mLifecycleRegistry;
    private ActivityLifecycleObserver mActivityLifecycleObserver = new ActivityLifecycleObserver("LifeCycleActivity");

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_lifecycle);
        //使用LifecycleRegistry类markState各个生命周期方法
        mLifecycleRegistry = new LifecycleRegistry(this);
        mLifecycleRegistry.markState(Lifecycle.State.CREATED);
        //获取Lifecycle生命周期 然后添加自定义的LifecycleObserver
        getLifecycle().addObserver(mActivityLifecycleObserver);
    }

    /**
     * 重写LifecycleOwner接口的getLifecycle方法
     *
     * @return LifecycleRegistry对象
     */

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

    @Override
    protected void onStart() {
        super.onStart();
        mLifecycleRegistry.markState(Lifecycle.State.STARTED);
        Log.d("MyLifecycleObserver", "自定义Activity的onStart方法 执行...");
    }

    @Override
    protected void onResume() {
        super.onResume();
        mLifecycleRegistry.markState(Lifecycle.State.RESUMED);
        Log.d("MyLifecycleObserver", "自定义Activity的onResume方法 执行...");
    }

    @Override
    protected void onStop() {
        super.onStop();
        mLifecycleRegistry.markState(Lifecycle.State.CREATED);
        Log.d("MyLifecycleObserver", "自定义Activity的onStop方法 执行...");
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mLifecycleRegistry.markState(Lifecycle.State.DESTROYED);
        Log.d("MyLifecycleObserver", "自定义Activity的onDestroy方法 执行...");
        //获取Lifecycle生命周期 然后移除自定义的LifecycleObserver
        getLifecycle().removeObserver(mActivityLifecycleObserver);
    }
}

LifecycleObserver实现类

package com.wjn.rxdemo.lifecycle.lifecycleobserver;

import android.util.Log;

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

/**
 * LifecycleObserver的实现类
 */

public class ActivityLifecycleObserver implements LifecycleObserver {

    private String mActivityName;

    public ActivityLifecycleObserver(String activityName) {
        mActivityName = activityName;
    }

    /**
     * 监听Activity的onStart方法
     */
    @OnLifecycleEvent(value = Lifecycle.Event.ON_START)
    public void activityOnStart(LifecycleOwner owner) {
        Log.d("MyLifecycleObserver", "监听自定义Activity的onStart方法 执行...owner：" + owner.getLifecycle().getCurrentState());
        Log.d("MyLifecycleObserver", "监听自定义Activity的onStart方法 执行...ActivityName：" + mActivityName);
    }

    /**
     * 监听Activity的onResume方法
     */
    @OnLifecycleEvent(value = Lifecycle.Event.ON_RESUME)
    public void activityOnResume(LifecycleOwner owner) {
        Log.d("MyLifecycleObserver", "监听自定义Activity的onResume方法 执行...owner：" + owner.getLifecycle().getCurrentState());
        Log.d("MyLifecycleObserver", "监听自定义Activity的onResume方法 执行...ActivityName：" + mActivityName);
    }

    /**
     * 监听Activity的onStop方法
     */
    @OnLifecycleEvent(value = Lifecycle.Event.ON_STOP)
    public void activityOnStop(LifecycleOwner owner) {
        Log.d("MyLifecycleObserver", "监听自定义Activity的onStop方法 执行...owner：" + owner.getLifecycle().getCurrentState());
        Log.d("MyLifecycleObserver", "监听自定义Activity的onStop方法 执行...ActivityName：" + mActivityName);
    }

    /**
     * 监听Activity的onDestroy方法
     */
    @OnLifecycleEvent(value = Lifecycle.Event.ON_DESTROY)
    public void activityOnDestroy(LifecycleOwner owner) {
        Log.d("MyLifecycleObserver", "监听自定义Activity的onDestroy方法 执行...owner：" + owner.getLifecycle().getCurrentState());
        Log.d("MyLifecycleObserver", "监听自定义Activity的onDestroy方法 执行...ActivityName：" + mActivityName);
    }
}

结果

进入Activity

D/MyLifecycleObserver: 监听自定义Activity的onStart方法 执行...owner：STARTED

D/MyLifecycleObserver: 监听自定义Activity的onStart方法 执行...ActivityName：LifeCycleActivity

D/MyLifecycleObserver: 自定义Activity的onStart方法 执行...



D/MyLifecycleObserver: 监听自定义Activity的onResume方法 执行...owner：RESUMED

D/MyLifecycleObserver: 监听自定义Activity的onResume方法 执行...ActivityName：LifeCycleActivity

D/MyLifecycleObserver: 自定义Activity的onResume方法 执行...

销毁Activity

D/MyLifecycleObserver: 监听自定义Activity的onStop方法 执行...owner：CREATED

D/MyLifecycleObserver: 监听自定义Activity的onStop方法 执行...ActivityName：LifeCycleActivity

D/MyLifecycleObserver: 自定义Activity的onStop方法 执行...



D/MyLifecycleObserver: 监听自定义Activity的onDestroy方法 执行...owner：DESTROYED

D/MyLifecycleObserver: 监听自定义Activity的onDestroy方法 执行...ActivityName：LifeCycleActivity

D/MyLifecycleObserver: 自定义Activity的onDestroy方法 执行...

四.Application基本使用

1.以前

Application级别管理每个Activity。或者判断APP进入前后台。是利用Application.ActivityLifecycleCallbacks接口。

2.代码

ActivityLifecycleCallbacks接口实现类

package com.wjn.rxdemo.lifecycle.application;

import android.app.Activity;
import android.app.Application;
import android.os.Bundle;
import android.util.Log;
import android.widget.Toast;

public class ApplicationActivityLifecycleCallbacks implements Application.ActivityLifecycleCallbacks {

    private int count = 0;

    @Override
    public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
        Log.d("ActivityLifecycle", "onActivityCreated方法 执行...activity：" + activity);
    }

    @Override
    public void onActivityStarted(Activity activity) {
        count++;
        if (count == 1) {
            Toast.makeText(activity, "APP进入前台", Toast.LENGTH_LONG).show();
        }
        Log.d("ActivityLifecycle", "onActivityStarted方法 执行...activity：" + activity);
    }

    @Override
    public void onActivityResumed(Activity activity) {
        Log.d("ActivityLifecycle", "onActivityResumed方法 执行...activity：" + activity);
    }

    @Override
    public void onActivityPaused(Activity activity) {
        Log.d("ActivityLifecycle", "onActivityPaused方法 执行...activity：" + activity);
    }

    @Override
    public void onActivityStopped(Activity activity) {
        count--;
        if (count == 0) {
            Toast.makeText(activity, "APP进入后台", Toast.LENGTH_LONG).show();
        }
        Log.d("ActivityLifecycle", "onActivityStopped方法 执行...activity：" + activity);
    }

    @Override
    public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
        Log.d("ActivityLifecycle", "onActivitySaveInstanceState方法 执行...activity：" + activity);
    }

    @Override
    public void onActivityDestroyed(Activity activity) {
        Log.d("ActivityLifecycle", "onActivityDestroyed方法 执行...activity：" + activity);
    }
}

Application中注册

package com.wjn.rxdemo;

import android.app.Application;

import com.wjn.rxdemo.lifecycle.application.ApplicationActivityLifecycleCallbacks;

public class MyApplication extends Application {

    @Override
    public void onCreate() {
        super.onCreate();
        registerActivityLifecycleCallbacks(new ApplicationActivityLifecycleCallbacks());
    }
}

3.结果(测试Demo只有一个MainActivity)

进入

D/ActivityLifecycle: onActivityCreated方法 执行...activity：com.wjn.rxdemo.MainActivity@aa22618


D/ActivityLifecycle: onActivityStarted方法 执行...activity：com.wjn.rxdemo.MainActivity@aa22618


D/ActivityLifecycle: onActivityResumed方法 执行...activity：com.wjn.rxdemo.MainActivity@aa22618

切到后台

D/ActivityLifecycle: onActivityPaused方法 执行...activity：com.wjn.rxdemo.MainActivity@aa22618


D/ActivityLifecycle: onActivitySaveInstanceState方法 执行...activity：com.wjn.rxdemo.MainActivity@aa22618


D/ActivityLifecycle: onActivityStopped方法 执行...activity：com.wjn.rxdemo.MainActivity@aa22618

切回前台

D/ActivityLifecycle: onActivityStarted方法 执行...activity：com.wjn.rxdemo.MainActivity@aa22618


D/ActivityLifecycle: onActivityResumed方法 执行...activity：com.wjn.rxdemo.MainActivity@aa22618

这个Application的ActivityLifecycleCallbacks接口。用来管理APP中所有的Activity的堆栈是比较好的。但是判断前后台切换就可能有点问题。

如上代码在onActivityStarted()中计数加1，在onActivityStopped方法中计数减1，从而判断前后台切换。

利用Jetpack的Lifecycle来判断前后台就更简单一点了。即使用Jetpack的ProcessLifecycleOwner 。

4.Gradle依赖

不同于Activity/Fragment级的监听生命周期方法。Application级监听前后台需要添加依赖

implementation "androidx.lifecycle:lifecycle-process:2.3.0"

5.代码

LifecycleObserver实现类

package com.wjn.rxdemo.lifecycle.application;

import android.util.Log;

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

public class ApplicationLifecycleObserver implements LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    private void onAppForeground() {
        Log.d("ApplicationLifecycle", "APP进入前台");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    private void onAppBackground() {
        Log.d("ApplicationLifecycle", "APP进入后台");
    }
}

Application注册

package com.wjn.rxdemo;

import android.app.Application;

import androidx.lifecycle.ProcessLifecycleOwner;

import com.wjn.rxdemo.lifecycle.application.ApplicationLifecycleObserver;

public class MyApplication extends Application {

    @Override
    public void onCreate() {
        super.onCreate();
        ProcessLifecycleOwner.get().getLifecycle().addObserver(new ApplicationLifecycleObserver());
    }
}

结果

进入

D/ApplicationLifecycle: APP进入前台

切到后台

D/ApplicationLifecycle: APP进入后台

切回前台

D/ApplicationLifecycle: APP进入前台

这样就可以简单的控制APP的前后台切换了。

6.说明

Application的生命周期监听和Activity/Fragment的生命周期监听。有不同之处。

<1> 第一个步骤是相同的。即都是实现LifecycleObserver接口，以注解的方式监听各个生命周期方法。

<2> 第二个步骤有区别。

Activity/Fragment中使用是在onCreate方法中直接获取Lifecycle对象，然后添加观察者。

getLifecycle().addObserver(new FragmentLifecycleObserver());

Application中使用是在onCreate方法中利用ProcessLifecycleOwner类获取LifecycleOwner对象然后再获取Lifecycle对象，最后添加观察者。还要另外依赖一个Jetpack的依赖

implementation "androidx.lifecycle:lifecycle-process:2.3.0"

jianning-wu

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Lifecycle详解

非常容易的将Activity/Fragment的生命周期方法抽离出来。直接使用getLifecycle()方法获取Lifecycle对象。直接使用getLifecycle()方法获取Lifecycle对象。既可以在具体的生命周期方法中获取状态也可以继续添加其他的观察者。自定义类实现LifecycleObserver接口。都是实现LifecycleObserver接口。onStop方法的owner是CREATED。onStop方法的owner是CREATED。LifecycleObserver接口。
复制链接

扫一扫