### 一、在Application中注册ActivityLifecycleCallbacks:
##### registerActivityLifecycleCallbacks(myActivityLifecycle);
```
public class MyApplication extends Application {
private static MyActivityLifecycle myActivityLifecycle;
@Override
public void onCreate() {
super.onCreate();
myActivityLifecycle = new MyActivityLifecycle();
registerActivityLifecycleCallbacks(myActivityLifecycle);
}
/**
*
* @return true 处于后台 false 前台
*/
public static boolean isAppBackground() {
if (myActivityLifecycle.getStartCount() == 0) {
return true;
}
return false;
}
}
```
### 二、MyActivityLifecycle实现Application.ActivityLifecycleCallbacks
```
public class MyActivityLifecycle implements Application.ActivityLifecycleCallbacks {
private int startCount;
@Override
public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
Log.e("==============","======>onActivityCreated");
}
@Override
public void onActivityStarted(Activity activity) {
Log.e("==============","======>onActivityStarted");
startCount++;
}
@Override
public void onActivityResumed(Activity activity) {
Log.e("==============","======>onActivityResumed");
}
@Override
public void onActivityPaused(Activity activity) {
Log.e("==============","======>onActivityPaused");
}
@Override
public void onActivityStopped(Activity activity) {
Log.e("==============","======>onActivityStopped");
startCount--;
}
@Override
public void onActivityDestroyed(Activity activity) {
Log.e("==============","======>onActivityDestroyed");
}
@Override
public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
Log.e("==============","======>onActivitySaveInstanceState");
}
public int getStartCount(){
return startCount;
}
}
```
===============================分割线======================================
上面是以前的老方法(也可以说是核心原理),现在在AndroidX中有新的(google帮我们写好了的)API
AppBackgroundObserver 实现了 LifecycleObserver 接口,通过注解监听生命周期。
```
class AppBackgroundObserver : LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
fun onAppBackground() {
Log.e("AppBackgroundObserver", "onAppBackground")
AppBackgroundUtil.isBackground = true
AppBackgroundUtil.dispatchBackgroundStatus(true)
}
@OnLifecycleEvent(Lifecycle.Event.ON_START)
fun onAppForeground() {
Log.e("AppBackgroundObserver", "onAppForeground")
AppBackgroundUtil.isBackground = false
AppBackgroundUtil.dispatchBackgroundStatus(false)
}
}
```
AppBackgroundUtil 工具类
```
object AppBackgroundUtil {
internal var isBackground: Boolean = true
private val observerList = mutableListOf<Observer>()
fun isAppBackground(): Boolean {
return isBackground
}
fun observe(observer: Observer) {
observerList.add(observer)
}
fun stopObserve(observer: Observer) {
observerList.remove(observer)
}
fun clearObserver(observer: Observer) {
observerList.clear()
}
internal fun dispatchBackgroundStatus(isAppBackground: Boolean) {
observerList.forEach {
it.onChange(isAppBackground)
}
}
interface Observer {
fun onChange(isAppBackground: Boolean)
}
}
```
在Application的onCreate()方法中注册:
```
ProcessLifecycleOwner.get().getLifecycle().addObserver(new AppBackgroundObserver());
```
上面是通过变量静态判断,我们还可以通过注册监听来动态观测。
```
AppBackgroundUtil.observe(object : AppBackgroundUtil.Observer {
override fun onChange(isAppBackground: Boolean) {
if (isAppBackground) {
// 后台
} else {
// 前台
}
}
})
```
ps:最后有兴趣的可以看看实现原理,其实核心还是最开始说的方式。