devbox
Gausst松鼠会
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

判断Android程序前后台切换的几种方法_android 12 判断切后台

作者：Gausst松鼠会 | 2024-02-26 06:52:14

赞

踩

android 12 判断切后台
Android在前后台切换时，我们可能需要做一些处理：发送
通知栏消息，提示APP在后台运行；或者我们需要暂停程序里的
某些线程，或者让线程池的执行时间降低，以保证较高的内存，
而避免被回收。那么我们有几种方式可以来判断呢？

思路1：在一个service里，使用一个线程，通过
ActivityManager.RunningAppProcessInfo轮询检测。

  1. public class AppService extends Service implements Runnable{
  2.  
  3.     public static boolean isOnBackground = true;
  4.     @Override
  5.     public IBinder onBind(Intent intent) {
  6.         return null;
  7.     }
  8.  
  9.     @Override
  10.     public void onCreate() {
  11.         // TODO Auto-generated method stub
  12.         super.onCreate();
  13.  
  14.         new Thread(this).start();
  15.     }
  16.     @Override
  17.     public int onStartCommand(Intent intent, int flags, int startId) {
  18.         // TODO Auto-generated method stub
  19.         return super.onStartCommand(intent, flags, startId);
  20.     }
  21.  
  22.     @Override
  23.     public void run() {
  24.         while(true){
  25.             boolean isOnBackgroundNew = DeviceUtils.isRunningOnBackground(this);
  26.             Log.d("appstatus", "app is on background ? " + (isOnBackgroundNew ?"yes":"no"));
  27.  
  28.             if(isOnBackgroundNew != isOnBackground){
  29.                 //检测到前后台状态不一致，做一些处理
  30.             }
  31.             try {
  32.                 Thread.sleep(500);
  33.             } catch (InterruptedException e) {
  34.                 // TODO Auto-generated catch block
  35.                 e.printStackTrace();
  36.             }
  37.         }
  38.     }
  39.     public static boolean isRunningOnBackground(Context context){
  40.  
  41.         ActivityManager acm = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
  42.         if(acm != null){
  43.             List<RunningAppProcessInfo> runApps = acm.getRunningAppProcesses();
  44.             if(runApps != null && !runApps.isEmpty()){
  45.                 for(RunningAppProcessInfo app : runApps){
  46.                     if(app.processName.equals(context.getPackageName())){
  47.                         if(app.importance == RunningAppProcessInfo.IMPORTANCE_BACKGROUND){
  48.                             return true;
  49.                         }
  50.                     }
  51.                 }
  52.             }
  53.         }
  54.         return false;
  55.     }
  56. }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56

缺点：需要创建service，以及线程，暂用大量CPU时间；切换至后台运行时会有延迟。

思路2：实现一个BaseActivity，然后让我们应用程序的Activity都继承自BaseActivity，子类继承BaseActivity非私属性和方法，通过BaseActivity的onStart()和onStop()方法中进行判断应用程序是否进入到后台并且是否从后台返回到了前台。这里我曾经遇到一个坑，先来看看我的第一个版本实现吧。

  1. public class BaseActivity extends Activity {
  2.  
  3.     public static boolean isBackground; //全局变量
  4.  
  5.     @Override
  6.     protected void onCreate(Bundle savedInstanceState) {
  7.         super.onCreate(savedInstanceState);
  8.         setContentView(R.layout.activity_base);
  9.     }
  10.  
  11.     @Override
  12.     protected void onStart() {
  13.         if (isBackground) {
  14.             //app 从后台唤醒，进入前台
  15.             isBackground = false;
  16.             Log.i("ACTIVITY", "程序从后台唤醒");
  17.         }
  18.         super.onStart();
  19.     }
  20.  
  21.     @Override
  22.     protected void onResume() {
  23.         super.onResume();
  24.     }
  25.  
  26.     @Override
  27.     protected void onPause() {
  28.         super.onPause();
  29.     }
  30.  
  31.     @Override
  32.     protected void onStop() {
  33.         if (isAppOnForeground()) {
  34.             //app 进入后台
  35.             isBackground = true;//记录当前已经进入后台
  36.             Log.i("ACTIVITY", "程序进入后台");
  37.         }
  38.         super.onStop();
  39.     }
  40.  
  41.     @Override
  42.     protected void onDestroy() {
  43.         super.onDestroy();
  44.     }
  45.  
  46.     /**
  47.      * APP是否处于前台唤醒状态
  48.      *
  49.      * @return
  50.      */
  51.     public boolean isAppOnForeground() {
  52.         ActivityManager activityManager = (ActivityManager) getApplicationContext().getSystemService(Context.ACTIVITY_SERVICE);
  53.         String packageName = getApplicationContext().getPackageName();
  54.         List<ActivityManager.RunningAppProcessInfo> appProcesses = activityManager
  55.                 .getRunningAppProcesses();
  56.         if (appProcesses == null)
  57.             return false;
  58.  
  59.         for (ActivityManager.RunningAppProcessInfo appProcess : appProcesses) {
  60.             // The name of the process that this object is associated with.
  61.             if (appProcess.processName.equals(packageName)
  62.                     && appProcess.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND) {
  63.                 return true;
  64.             }
  65.         }
  66.  
  67.         return false;
  68.     }
  69. }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69

isAppOnForeground()在不同的Android系统上返回值不同。我的想法是美好的，可是实际却是一个坑。当我点击home时，onStop也被调用了，可以isAppOnForeground()却返回false，系统还没更新状态吗？这可能要去深究源代码才清楚了。后来，就有了以下改进版。

  1. public class BaseActivity extends Activity {
  2.  
  3.     public static boolean activityActive; //全局变量,表示当前在前台的activity数量
  4.     public static boolean isBackground ;
  5.     @Override
  6.     protected void onCreate(Bundle savedInstanceState) {
  7.         super.onCreate(savedInstanceState);
  8.         setContentView(R.layout.activity_base);
  9.     }
  10.  
  11.     @Override
  12.     protected void onStart() {
  13.         //app 从后台唤醒，进入前台
  14.         activityActive++；
  15.         isBackground = false;
  16.         Log.i("ACTIVITY", "程序从后台唤醒");
  17.  
  18.         super.onStart();
  19.     }
  20.  
  21.     @Override
  22.     protected void onResume() {
  23.         super.onResume();
  24.     }
  25.  
  26.     @Override
  27.     protected void onPause() {
  28.         super.onPause();
  29.     }
  30.  
  31.     @Override
  32.     protected void onStop() {
  33.         activityActive--；
  34.         if (activityActive == 0) {
  35.             //app 进入后台
  36.             isBackground = true;//记录当前已经进入后台
  37.             Log.i("ACTIVITY", "程序进入后台");
  38.         }
  39.         super.onStop();
  40.     }
  41.  
  42.     @Override
  43.     protected void onDestroy() {
  44.         super.onDestroy();
  45.     }
  46. }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46

这个方法是不是很简单 ！ ^_^

思路3：其实跟第二种改进版是一样的，只不过放在Application中实现了，感觉还是第二种方法简单哈。

  1. public class TheApplication extends Application {
  2.  
  3.     private int mFinalCount;
  4.  
  5.     @Override
  6.     public void onCreate() {
  7.         super.onCreate();
  8.         registerActivityLifecycleCallbacks(new ActivityLifecycleCallbacks() {
  9.             @Override
  10.             public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
  11.  
  12.             }
  13.  
  14.             @Override
  15.             public void onActivityStarted(Activity activity) {
  16.                 mFinalCount++;
  17.                 //如果mFinalCount ==1，说明是从后台到前台
  18.                 Log.e("onActivityStarted", mFinalCount +"");
  19.                 if (mFinalCount == 1){
  20.                     //说明从后台回到了前台
  21.                 }
  22.             }
  23.  
  24.             @Override
  25.             public void onActivityResumed(Activity activity) {
  26.  
  27.             }
  28.  
  29.             @Override
  30.             public void onActivityPaused(Activity activity) {
  31.  
  32.             }
  33.  
  34.             @Override
  35.             public void onActivityStopped(Activity activity) {
  36.                 mFinalCount--;
  37.                 //如果mFinalCount ==0，说明是前台到后台
  38.                 Log.i("onActivityStopped", mFinalCount +"");
  39.                 if (mFinalCount == 0){
  40.                     //说明从前台回到了后台
  41.                 }
  42.             }
  43.  
  44.             @Override
  45.             public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
  46.  
  47.             }
  48.  
  49.             @Override
  50.             public void onActivityDestroyed(Activity activity) {
  51.  
  52.             }
  53.         });
  54.     }
  55. }
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Gausst松鼠会/article/detail/144778
推荐阅读

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。