Android中应用前后台切换监听的实现详解

前言

最近在工作中遇到了这么一个需求：如何实现 android 应用前后台切换的监听？下面来一起看看详细的介绍：

ios 内边是可以实现的，appdelegate 给了一个回调监听：

@uiapplicationmain
class appdelegate: uiresponder, uiapplicationdelegate {
 func applicationwillresignactive(_ application: uiapplication) {
 // sent when the application is about to move from active to inactive state. this can occur for certain types of temporary interruptions (such as an incoming phone call or sms message) or when the user quits the application and it begins the transition to the background state.
 // use this method to pause ongoing tasks, disable timers, and invalidate graphics rendering callbacks. games should use this method to pause the game.
 }
 func applicationdidenterbackground(_ application: uiapplication) {
 // use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later.
 // if your application supports background execution, this method is called instead of applicationwillterminate: when the user quits.
 }
 func applicationwillenterforeground(_ application: uiapplication) {
 // called as part of the transition from the background to the active state; here you can undo many of the changes made on entering the background.
 }
 func applicationdidbecomeactive(_ application: uiapplication) {
 // restart any tasks that were paused (or not yet started) while the application was inactive. if the application was previously in the background, optionally refresh the user interface.
 }
}

我保留了系统注释。一个ios应用周期，大概的流程是这样的。

应用从前台进入到后台：

applicationwillresignactive() -> applicationdidenterbackground()

应用从后台恢复到前台：

applicationwillenterforeground() -> applicationdidbecomeactive()

android 中也存在 application，但是并没有提供前后台切换的监听。

倒不如说，在 android 中，压根就没有应用前后台的概念。

android 中基本页面单位是 activity。

activity 有自己的生命周期，但是 application 却没有一个整体的生命周期。

我们可以通过监听 activity 的生命周期，来模拟实现一个 application 的生命周期。

activity 的生命周期不在阐述，写过 android 的都应该知道。

我们假设现在有两个 activity 分别是 a 和 b，a 是启动页面，那么生命周期回调是这样的：（我们忽略掉一些不关心的回调）

a 被启动或者 a 进入前台

a.onstart()
a.onresume()

从 a 跳转到 b：

a.onpause()
b.onstart()
b.onresume()
a.onstop()

从 b 返回 a：

b.onpause()
a.onstart()
a.onresume()
b.onstop()

a 被关闭或者 a 进入后台

a.onpause()
a.onstop()

注意上面两个页面回调的启动顺序。

onresume 和 onpause 是一组，两个页面之间是顺序调用。

onstart 和 onstop 是一组，两个页面之间是交叉调用。

也就是说，a 启动到 b，会先调用 b.onstart() ，然后再调用 a.onstop() ；而 b 返回 a 则是相反的，会先调用 a.onstart() ，然后再调用 b.onstop() 。

利用这个特性，我们可以做一个全局计数器，来记录前台页面的数量，在所有 activity.onstart() 中计数器 +1，在所有 activity.onstop() 中计数器 -1。计数器数目大于0，说明应用在前台；计数器数目等于0，说明应用在后台。计数器从1变成0，说明应用从前台进入后台；计数器从0变成1，说明应用从后台进入前台。

有了思路，我们来实现。

application 提供了一个监听器用于监听整个应用中 activity 声明周期：application.activitylifecyclecallbacks 。

这个监听器要求 api >= 14。对应 api < 14 的情况，可以通过编写一个 baseactivity，然后让所有的 activity 都集成这个类来实现整个应用 activity 声明周期的监听，效果是相同的。

api >= 14，实现如下：

public class applicationlistener implements application.activitylifecyclecallbacks {
 private int foregroundcount = 0; // 位于前台的 activity 的数目
 @override
 public void onactivitystarted(final activity activity) {
  if (foregroundcount <= 0) {
   // todo 这里处理从后台恢复到前台的逻辑
  }
  foregroundcount++;
 }
 @override
 public void onactivitystopped(activity activity) {
  foregroundcount--;
  if (foregroundcount <= 0) {
   // todo 这里处理从前台进入到后台的逻辑
  }
 }
 /*
  * 下面回调，我们都不需要
  */
 @override
 public void onactivitycreated(activity activity, bundle savedinstancestate) {}
 @override
 public void onactivityresumed(activity activity) {}
 @override
 public void onactivitypaused(activity activity) {}
 @override
 public void onactivitysaveinstancestate(activity activity, bundle outstate) {}
 @override
 public void onactivitydestroyed(activity activity) {}
}

我们在 application 中注册这个监听器来发挥效果：

public class myapplication extends application {
 @override
 public void oncreate() {
  super.oncreate();
  registeractivitylifecyclecallbacks(new applicationlistener());
 }
}

对于 api < 14 的情况，baseactivity 实现如下：

public class baseactivity extends appcompatactivity {
 private static int foregroundcount = 0; // 注意是个静态变量
 @override
 protected void onstart() {
  super.onstart();
  if (foregroundcount <= 0) {
   // todo 这里处理从后台恢复到前台的逻辑
  }
  foregroundcount++;
 }
 @override
 protected void onstop() {
  foregroundcount--;
  if (foregroundcount <= 0) {
   // todo 这里处理从前台进入到后台的逻辑
  }
  super.onstop();
 }
}

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作能带来一定的帮助，如有疑问大家可以留言交流，谢谢大家对的支持。