使用getApplicationState().isInForeground()怎么样?

这段代码将在任何情况下检查前台和后台:

Java代码:

private static boolean isApplicationForeground(Context context) {
    KeyguardManager keyguardManager =
            (KeyguardManager) context.getSystemService(Context.KEYGUARD_SERVICE);

    if (keyguardManager.isKeyguardLocked()) {
        return false;
    }
    int myPid = Process.myPid();

    ActivityManager activityManager =
            (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);

    List<ActivityManager.RunningAppProcessInfo> list;

    if ((list = activityManager.getRunningAppProcesses()) != null) {
        for (ActivityManager.RunningAppProcessInfo aList : list) {
            ActivityManager.RunningAppProcessInfo info;
            if ((info = aList).pid == myPid) {
                return info.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND;
            }
        }
    }
    return false;
}

芬兰湾的科特林代码:

private fun isApplicationForeground(context: Context): Boolean {
        val keyguardManager = context.getSystemService(Context.KEYGUARD_SERVICE) as KeyguardManager
        if (keyguardManager.isKeyguardLocked) {
            return false
        }
        val myPid = Process.myPid()
        val activityManager = context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
        var list: List<ActivityManager.RunningAppProcessInfo>
        if (activityManager.runningAppProcesses.also { list = it } != null) {
            for (aList in list) {
                var info: ActivityManager.RunningAppProcessInfo
                if (aList.also { info = it }.pid == myPid) {
                    return info.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND
                }
            }
        }
        return false
    }

根据CommonsWare和Key所说的，你可以扩展Application类，并让你所有的活动在onPause/onResume方法上调用它。这将允许您知道哪些活动是可见的，但这可能会得到更好的处理。

你能详细说明一下你的想法吗?当你说在后台运行，你的意思是简单地让你的应用程序仍然在内存中，即使它目前不在屏幕上?你有没有考虑过使用服务作为一种更持久的方式来管理你的应用程序，当它不在焦点?

在@玉米秆回答的基础上，包括一些有用的功能。

额外的功能:

引入了单例模式，所以你可以在应用程序的任何地方这样做: 增加了重复事件的处理(见注释//对可见性的变化采取一些行动和//对前景的变化采取一些行动)

App.java

public class App extends Application {
    @Override
    public void onCreate() {
        super.onCreate();

        registerActivityLifecycleCallbacks(AppLifecycleHandler.getInstance());
    }
}

AppLifecycleHandler.java

public class AppLifecycleHandler implements Application.ActivityLifecycleCallbacks {
    private int resumed;
    private int started;

    private final String DebugName = "AppLifecycleHandler";

    private boolean isVisible = false;
    private boolean isInForeground = false;

    private static AppLifecycleHandler instance;

    public static AppLifecycleHandler getInstance() {
        if (instance == null) {
            instance = new AppLifecycleHandler();
        }

        return instance;
    }

    private AppLifecycleHandler() {
    }

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

    @Override
    public void onActivityDestroyed(Activity activity) {
    }

    @Override
    public void onActivityResumed(Activity activity) {
        ++resumed;
        android.util.Log.w(DebugName, "onActivityResumed -> application is in foreground: " + (resumed > 0) + " (" + activity.getClass() + ")");
        setForeground((resumed > 0));
    }

    @Override
    public void onActivityPaused(Activity activity) {
        --resumed;
        android.util.Log.w(DebugName, "onActivityPaused -> application is in foreground: " + (resumed > 0) + " (" + activity.getClass() + ")");
        setForeground((resumed > 0));
    }

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

    @Override
    public void onActivityStarted(Activity activity) {
        ++started;
        android.util.Log.w(DebugName, "onActivityStarted -> application is visible: " + (started > 0) + " (" + activity.getClass() + ")");
        setVisible((started > 0));
    }

    @Override
    public void onActivityStopped(Activity activity) {
        --started;
        android.util.Log.w(DebugName, "onActivityStopped -> application is visible: " + (started > 0) + " (" + activity.getClass() + ")");
        setVisible((started > 0));
    }

    private void setVisible(boolean visible) {
        if (isVisible == visible) {
            // no change
            return;
        }

        // visibility changed
        isVisible = visible;
        android.util.Log.w(DebugName, "App Visiblility Changed -> application is visible: " + isVisible);

        // take some action on change of visibility
    }

    private void setForeground(boolean inForeground) {
        if (isInForeground == inForeground) {
            // no change
            return;
        }

        // in foreground changed
        isInForeground = inForeground;
        android.util.Log.w(DebugName, "App In Foreground Changed -> application is in foreground: " + isInForeground);

        // take some action on change of in foreground

    }

    public static boolean isApplicationVisible() {
        return AppLifecycleHandler.getInstance().started > 0;
    }

    public static boolean isApplicationInForeground() {
        return AppLifecycleHandler.getInstance().resumed > 0;
    }
}

现在回答可能已经太迟了，但如果有人来访，我建议有一个解决方案， 一个应用程序想要知道它的状态是在后台还是在前台的原因可以有很多，有几个是， 1. 当用户在BG时显示祝酒和通知。 2.第一次从BG来的用户执行一些任务，如投票，重画等。

Idolon和其他人的解决方案解决了第一部分，但没有解决第二部分。如果你的应用程序中有多个活动，并且用户在它们之间切换，那么当你处于第二个活动时，可见标志将为假。所以它不能被确定地使用。

我做了一些CommonsWare建议的事情，“如果服务确定没有可见的活动，并且在一段时间内保持这种状态，那么在下一个逻辑停止点停止数据传输。”

粗体部分很重要，可以用来完成第二项。所以我所做的是一旦我得到onActivityPaused()，不改变可见直接为假，而是有一个3秒的定时器(这是下一个活动应该启动的最大值)，如果没有onactivityresume()调用在接下来的3秒，改变可见为假。 类似地，在onactivityresume()如果有一个定时器，然后我取消它。 总之，可见变成了isAppInBackground。

对不起，不能复制粘贴代码…

自从Android API 16以来，有一个简单的方法来检查应用程序是否在前台。这可能不是万无一失的，但Android上没有万无一失的方法。当你的服务接收到来自服务器的更新，并且必须决定是否显示通知时，这个方法就足够好了(因为如果UI是前台，用户会注意到更新而不通知)。

RunningAppProcessInfo myProcess = new RunningAppProcessInfo();
ActivityManager.getMyMemoryState(myProcess);
isInBackground = myProcess.importance != RunningAppProcessInfo.IMPORTANCE_FOREGROUND;