如果你想知道一个特定的活动是否在前台，如果你是一个没有直接访问应用程序的SDK，那么没有一个答案非常适合特定的情况。对我来说，我在后台线程刚刚收到一个新的聊天消息的推送通知，只想在聊天屏幕不在前台时显示系统通知。

使用ActivityLifecycleCallbacks，正如在其他答案中推荐的那样，我已经创建了一个小的util类，它包含MyActivity是否在前台的逻辑。

class MyActivityMonitor(context: Context) : Application.ActivityLifecycleCallbacks {

private var isMyActivityInForeground = false

init {
    (context.applicationContext as Application).registerActivityLifecycleCallbacks(this)
}

fun isMyActivityForeground() = isMyActivityInForeground

override fun onActivityPaused(activity: Activity?) {
    if (activity is MyActivity) {
        isMyActivityInForeground = false
    }
}

override fun onActivityResumed(activity: Activity?) {
    if (activity is MyActivity) {
        isMyActivityInForeground = true
    }
}

}

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

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

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

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

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

检测应用程序是否在后台运行的方法很少，但只有一种是完全可靠的:

The right solution (credits go to Dan, CommonsWare and NeTeInStEiN) Track visibility of your application by yourself using Activity.onPause, Activity.onResume methods. Store "visibility" status in some other class. Good choices are your own implementation of the Application or a Service (there are also a few variations of this solution if you'd like to check activity visibility from the service).   Example Implement custom Application class (note the isActivityVisible() static method): public class MyApplication extends Application { public static boolean isActivityVisible() { return activityVisible; } public static void activityResumed() { activityVisible = true; } public static void activityPaused() { activityVisible = false; } private static boolean activityVisible; } Register your application class in AndroidManifest.xml: <application android:name="your.app.package.MyApplication" android:icon="@drawable/icon" android:label="@string/app_name" > Add onPause and onResume to every Activity in the project (you may create a common ancestor for your Activities if you'd like to, but if your activity is already extended from MapActivity/ListActivity etc. you still need to write the following by hand): @Override protected void onResume() { super.onResume(); MyApplication.activityResumed(); } @Override protected void onPause() { super.onPause(); MyApplication.activityPaused(); }   Update ActivityLifecycleCallbacks were added in API level 14 (Android 4.0). You can use them to track whether an activity of your application is currently visible to the user. Check Cornstalks' answer below for the details. The wrong one I used to suggest the following solution: You can detect currently foreground/background application with ActivityManager.getRunningAppProcesses() which returns a list of RunningAppProcessInfo records. To determine if your application is on the foreground check RunningAppProcessInfo.importance field for equality to RunningAppProcessInfo.IMPORTANCE_FOREGROUND while RunningAppProcessInfo.processName is equal to your application package name. Also if you call ActivityManager.getRunningAppProcesses() from your application UI thread it will return importance IMPORTANCE_FOREGROUND for your task no matter whether it is actually in the foreground or not. Call it in the background thread (for example via AsyncTask) and it will return correct results. While this solution may work (and it indeed works most of the time) I strongly recommend to refrain from using it. And here's why. As Dianne Hackborn wrote: These APIs are not there for applications to base their UI flow on, but to do things like show the user the running apps, or a task manager, or such. Yes there is a list kept in memory for these things. However, it is off in another process, managed by threads running separately from yours, and not something you can count on (a) seeing in time to make the correct decision or (b) have a consistent picture by the time you return. Plus the decision about what the "next" activity to go to is always done at the point where the switch is to happen, and it is not until that exact point (where the activity state is briefly locked down to do the switch) that we actually know for sure what the next thing will be. And the implementation and global behavior here is not guaranteed to remain the same in the future. I wish I had read this before I posted an answer on the SO, but hopefully it's not too late to admit my error. Another wrong solution Droid-Fu library mentioned in one of the answers uses ActivityManager.getRunningTasks for its isApplicationBroughtToBackground method. See Dianne's comment above and don't use that method either.

没有任何解决方案适合我，但我提出了一个原始的解决方案。这应该有用。如果isAppBackground返回false，那么app必须在前台。

public static boolean isAppBackground(Context context){
        boolean isBackground=true;
        ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
        if(Build.VERSION.SDK_INT > Build.VERSION_CODES.KITKAT_WATCH){
            List<ActivityManager.RunningAppProcessInfo> runningProcesses =activityManager.getRunningAppProcesses();
            for(ActivityManager.RunningAppProcessInfo processInfo:runningProcesses){
                if(processInfo.importance==ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND){
                    for(String activeProcess:processInfo.pkgList){
                        if(activeProcess.equals(context.getPackageName())){
                            isBackground = false;
                        }
                    }
                }
            }
        }else{
            List<ActivityManager.RunningTaskInfo> taskInfo = activityManager.getRunningTasks(1);
            if(taskInfo.size()>0) {
                ComponentName componentName = taskInfo.get(0).topActivity;
                if(componentName.getPackageName().equals(context.getPackageName())){
                    isBackground = false;
                }
            }
        }
        return isBackground;
    }

fun isAppInForeground(): Boolean {
    val activityManager = getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager ?: return false

    val appProcesses = activityManager.runningAppProcesses ?: return false

    val packageName = packageName
    for (appProcess in appProcesses) {
        if (appProcess.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND && appProcess.processName == packageName) {
            return true
        }
    }

    return false
}

在我看来，许多答案引入了大量的代码，带来了很多复杂性和可读性。

当人们问SO如何在服务和活动之间通信时，我通常建议使用LocalBroadcastManager。

---

Why?

我引用一下医生的话:

你知道你广播的数据不会离开你的应用程序，所以不需要担心泄露私人数据。 其他应用程序不可能将这些广播发送到你的应用程序，所以你不需要担心他们可以利用的安全漏洞。 这比通过系统发送全球广播更有效。

文档里没有:

它不需要外部库 代码是最少的 它易于实现和理解 没有自定义的自实现回调/超单例/进程内 任何模式…… 没有对Activity, Application，…

---

描述

你想要检查是否有Activity当前在前台。您通常在服务或应用程序类中这样做。

这意味着，您的Activity对象成为信号的发送者(I'm on / I'm off)。另一方面，您的服务成为接收者。

Activity有两个时刻告诉你它是在前台还是在后台(是的，只有两个…不是6)。

当Activity进入前台时，onResume()方法被触发(也在onCreate()之后调用)。

当Activity回到后面时，onPause()被调用。

在这些时刻，您的活动应该向您的服务发送信号，以描述其状态。

在有多个Activity的情况下，记住一个Activity先进入后台，然后另一个进入前台。

所以情况是:*

Activity1 -- send --> Signal:OFF
Activity2 -- send --> Signal:ON

服务/应用程序将简单地监听这些信号并进行相应的操作。

---

代码(TLDR)

你的服务必须实现一个BroadcastReceiver来监听信号。

this.localBroadcastReceiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
        // received data if Activity is on / off
    }
}

public static final IntentFilter SIGNAL_FILTER = new IntentFilter("com.you.yourapp.MY_SIGNAL") 

在服务中注册接收者::onCreate()

@Override
protected void onCreate() {
    LocalBroadcastManager.getInstance(getApplicationContext()).registerReceiver(this.localBroadcastReceiver, SIGNAL_FILTER);
}

在Service::onDestroy()中取消注册

@Override
protected void onDestroy() {
    // I'm dead, no need to listen to anything anymore.
    LocalBroadcastManager.getInstance(getApplicationContext()).unregisterReceiver(this.localBroadcastReceiver);
}

现在你的Activity必须传达它们的状态。

在活动::onResume ()

Intent intent = new Intent();
intent.setAction(SomeActivity.SIGNAL_FILTER); // put ON boolean in intent    
LocalBroadcastManager.getInstance(getApplicationContext()).sendBroadcast(intent);

在活动::onPause ()

Intent intent = new Intent();
intent.setAction(SomeActivity.SIGNAL_FILTER); // put OFF boolean in intent    
LocalBroadcastManager.getInstance(getApplicationContext()).sendBroadcast(intent);

---

这是一种非常非常常见的情况

开发人员:我想从我的服务发送数据并更新活动。我如何检查活动是否在前景?

通常不需要检查Activity是否在前台。只需从服务中通过LocalBroadcastManager发送数据。如果活动处于开启状态，那么它将做出响应并采取行动。

对于这种非常常见的情况，服务成为发送方，活动实现BroadcastReceiver。

因此，在您的活动中创建一个Receiver。在onResume()中注册，在onPause()中取消注册。不需要使用其他生命周期方法。

在onReceive()中定义Receiver行为(更新ListView，做这个，做那个，…)

这样Activity只会在它在前台的时候监听，如果它在后面或者被销毁了什么也不会发生。

在多个活动的情况下，任何一个活动都将响应(如果它们也实现了Receiver)。

如果所有人都在后台，没有人会回应，信号就会丢失。

通过Intent(见上面的代码)通过指定信号ID从服务发送数据。

---

除了多窗口支持。这可能很棘手(如果需要，请测试它)…