本章节讲述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"