判断Android 应用前后台的几种方式

方法一： 通过Application.ActivityLifecycleCallbacks

API 14之后，在Application类中，提供了一个应用生命周期回调的注册方法，用来对应用的生命周期进行集中管理，这个接口叫registerActivityLifecycleCallbacks，可以通过它注册自己的ActivityLifeCycleCallback，每一个Activity的生命周期都会回调到这里的对应方法

public class ForegroundCallbacks implements Application.ActivityLifecycleCallbacks {
    public static final long CHECK_DELAY = 500;
    public static final String TAG = ForegroundCallbacks.class.getName();

    public interface Listener {
        public void onBecameForeground();

        public void onBecameBackground();
    }

    private static ForegroundCallbacks instance;
    private boolean foreground = false, paused = true;
    private Handler handler = new Handler();
    private List<Listener> listeners = new CopyOnWriteArrayList<Listener>();
    private Runnable check;

    public static ForegroundCallbacks init(Application application) {
        if (instance == null) {
            instance = new ForegroundCallbacks();
            application.registerActivityLifecycleCallbacks(instance);
        }
        return instance;
    }

    public static ForegroundCallbacks get(Application application) {
        if (instance == null) {
            init(application);
        }
        return instance;
    }

    public static ForegroundCallbacks get(Context ctx) {
        if (instance == null) {
            Context appCtx = ctx.getApplicationContext();
            if (appCtx instanceof Application) {
                init((Application) appCtx);
            }
            throw new IllegalStateException(
                    "Foreground is not initialised and " +
                            "cannot obtain the Application object");
        }
        return instance;
    }

    public static ForegroundCallbacks get() {
        if (instance == null) {
            throw new IllegalStateException(
                    "Foreground is not initialised - invoke " +
                            "at least once with parameterised init/get");
        }
        return instance;
    }

    public boolean isForeground() {
        return foreground;
    }

    public boolean isBackground() {
        return !foreground;
    }

    public void addListener(Listener listener) {
        listeners.add(listener);
    }

    public void removeListener(Listener listener) {
        listeners.remove(listener);
    }

    @Override
    public void onActivityResumed(Activity activity) {
        paused = false;
        boolean wasBackground = !foreground;
        foreground = true;
        if (check != null)
            handler.removeCallbacks(check);
        if (wasBackground) {
            Log.d(TAG, "went foreground");

            for (Listener l : listeners) {
                try {
                    l.onBecameForeground();


                } catch (Exception exc) {
                    Log.d(TAG, "Listener threw exception!:" + exc.toString());
                }
            }
        } else {
            Log.d(TAG, "still foreground");
        }
    }

    @Override
    public void onActivityPaused(Activity activity) {
        paused = true;
        if (check != null)
            handler.removeCallbacks(check);
        handler.postDelayed(check = new Runnable() {
            @Override
            public void run() {
                if (foreground && paused) {
                    foreground = false;
                    Log.d(TAG, "went background");
                    for (Listener l : listeners) {
                        try {
                            l.onBecameBackground();
                        } catch (Exception exc) {
                            Log.d(TAG, "Listener threw exception!:" + exc.toString());
                        }
                    }
                } else {
                    Log.d(TAG, "still foreground");
                }
            }
        }, CHECK_DELAY);
    }

    @Override
    public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
    }

    @Override
    public void onActivityStarted(Activity activity) {
    }

    @Override
    public void onActivityStopped(Activity activity) {
    }

    @Override
    public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
    }

    @Override
    public void onActivityDestroyed(Activity activity) {
    }
}

Application 里进行注册监听

        ForegroundCallbacks.init(this);

        ForegroundCallbacks.get().addListener(new ForegroundCallbacks.Listener() {
            @Override
            public void onBecameForeground() {

                isAppForeground =  true;
            }

            @Override
            public void onBecameBackground() {

                isAppForeground = false;
            }
        });

方法二、通过RunningTaskInfo类判断(需要额外权限):

/**
*判断当前应用程序处于前台还是后台
*/
public static boolean isApplicationBroughtToBackground(final Context context) {
ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
List<RunningTaskInfo> tasks = am.getRunningTasks(1);
if (!tasks.isEmpty()) {
ComponentName topActivity = tasks.get(0).topActivity;
if (!topActivity.getPackageName().equals(context.getPackageName())) {
return true;
}
}
return false;

}

需要在AndroidMenitfest.xml文件中添加以下权限

<uses-permission android:name="android.permission.GET_TASKS" /> 

方法三、 通过RunningAppProcessInfo类判断(不需要额外权限)

public static boolean isBackground(Context context) {

ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
List<RunningAppProcessInfo> appProcesses = activityManager.getRunningAppProcesses();
for (RunningAppProcessInfo appProcess : appProcesses) {
if (appProcess.processName.equals(context.getPackageName())) {
if (appProcess.importance == RunningAppProcessInfo.IMPORTANCE_BACKGROUND) {
Log.i("后台", appProcess.processName);
return true;
}else{
Log.i("前台", appProcess.processName);
return false;
}
}
}
return false;
}

方法四、在BaseActivity 中对每一个Activity进行管理

public class ActivityManagerHelper {
    private static ActivityManagerHelper sManager;
    private Stack<WeakReference<Activity>> mActivityStack;

    private ActivityManagerHelper() {
    }

    public static ActivityManagerHelper getManager() {
        if (sManager == null) {
            Class var0 = ActivityManagerHelper.class;
            synchronized(ActivityManagerHelper.class) {
                if (sManager == null) {
                    sManager = new ActivityManagerHelper();
                }
            }
        }

        return sManager;
    }

    public void addActivity(Activity activity) {
        if (this.mActivityStack == null) {
            this.mActivityStack = new Stack();
        }

        this.mActivityStack.add(new WeakReference(activity));
    }

    public boolean deleteActivity(Activity activity) {
        if (activity != null && this.mActivityStack != null) {
            Iterator it = this.mActivityStack.iterator();

            while(it.hasNext()) {
                WeakReference<Activity> activityReference = (WeakReference)it.next();
                Activity temp = (Activity)activityReference.get();
                if (temp == null) {
                    it.remove();
                } else if (temp == activity) {
                    it.remove();
                    return true;
                }
            }
        }

        return false;
    }

    public void checkWeakReference() {
        if (this.mActivityStack != null) {
            Iterator it = this.mActivityStack.iterator();

            while(it.hasNext()) {
                WeakReference<Activity> activityReference = (WeakReference)it.next();
                Activity temp = (Activity)activityReference.get();
                if (temp == null) {
                    it.remove();
                }
            }
        }

    }

    public Activity currentActivity() {
        this.checkWeakReference();
        return this.mActivityStack != null && !this.mActivityStack.isEmpty() ? (Activity)((WeakReference)this.mActivityStack.lastElement()).get() : null;
    }

    public void finishCurrentActivity() {
        Activity activity = this.currentActivity();
        if (activity != null) {
            this.finishSpecificActivity(activity);
        }

    }

    public void finishSpecificActivity(Activity activity) {
        if (this.deleteActivity(activity)) {
            activity.finish();
        }

    }

    public void finishSpecificActivity(Class<?> cls) {
        if (this.mActivityStack != null) {
            Iterator it = this.mActivityStack.iterator();

            while(it.hasNext()) {
                WeakReference<Activity> activityReference = (WeakReference)it.next();
                Activity activity = (Activity)activityReference.get();
                if (activity == null) {
                    it.remove();
                } else if (activity.getClass().equals(cls)) {
                    it.remove();
                    activity.finish();
                }
            }
        }

    }

    public void finishAllActivity() {
        if (this.mActivityStack != null) {
            Iterator var1 = this.mActivityStack.iterator();

            while(var1.hasNext()) {
                WeakReference<Activity> activityReference = (WeakReference)var1.next();
                Activity activity = (Activity)activityReference.get();
                if (activity != null) {
                    activity.finish();
                }
            }

            this.mActivityStack.clear();
        }

    }

    public void exitApp() {
        try {
            this.finishAllActivity();
            System.exit(0);
            Process.killProcess(Process.myPid());
        } catch (Exception var2) {
            var2.printStackTrace();
        }

    }
}

BaseActivity 中的写法

   protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ActivityManagerHelper.getManager().addActivity(this);
        }

   protected void onDestroy() {
        super.onDestroy();
        ActivityManagerHelper.getManager().deleteActivity(this);
    }