这篇旧文章的另一个解决方案(对那些可能有帮助的人来说):

---

<application android:name=".BaseApplication" ... >

---

public class BaseApplication extends Application {

    private class Status {
        public boolean isVisible = true;
        public boolean isFocused = true;
    }

    private Map<Activity, Status> activities;

    @Override
    public void onCreate() {
        activities = new HashMap<Activity, Status>();
        super.onCreate();
    }

    private boolean hasVisibleActivity() {
        for (Status status : activities.values())
            if (status.isVisible)
                return true;
        return false;
    }

    private boolean hasFocusedActivity() {
        for (Status status : activities.values())
            if (status.isFocused)
                return true;
        return false;
    }

    public void onActivityCreate(Activity activity, boolean isStarting) {
        if (isStarting && activities.isEmpty())
            onApplicationStart();
        activities.put(activity, new Status());
    }

    public void onActivityStart(Activity activity) {
        if (!hasVisibleActivity() && !hasFocusedActivity())
            onApplicationForeground();
        activities.get(activity).isVisible = true;
    }

    public void onActivityWindowFocusChanged(Activity activity, boolean hasFocus) {
        activities.get(activity).isFocused = hasFocus;
    }

    public void onActivityStop(Activity activity, boolean isFinishing) {
        activities.get(activity).isVisible = false;
        if (!isFinishing && !hasVisibleActivity() && !hasFocusedActivity())
            onApplicationBackground();
    }

    public void onActivityDestroy(Activity activity, boolean isFinishing) {
        activities.remove(activity);
        if(isFinishing && activities.isEmpty())
            onApplicationStop();
    }

    private void onApplicationStart() {Log.i(null, "Start");}
    private void onApplicationBackground() {Log.i(null, "Background");}
    private void onApplicationForeground() {Log.i(null, "Foreground");}
    private void onApplicationStop() {Log.i(null, "Stop");}

}

---

public class MyActivity extends BaseActivity {...}

---

public class BaseActivity extends Activity {

    private BaseApplication application;

    @Override
    protected void onCreate(Bundle state) {
        application = (BaseApplication) getApplication();
        application.onActivityCreate(this, state == null);
        super.onCreate(state);
    }

    @Override
    protected void onStart() {
        application.onActivityStart(this);
        super.onStart();
    }

    @Override
    public void onWindowFocusChanged(boolean hasFocus) {
        application.onActivityWindowFocusChanged(this, hasFocus);
        super.onWindowFocusChanged(hasFocus);
    }

    @Override
    protected void onStop() {
        application.onActivityStop(this, isFinishing());
        super.onStop();
    }

    @Override
    protected void onDestroy() {
        application.onActivityDestroy(this, isFinishing());
        super.onDestroy();
    }

}

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

当人们问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从服务发送数据。

---

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

Idolon的答案是容易出错的，更复杂的，尽管在这里重复检查android应用程序是在前台或不是?从后台任务或服务中确定当前的前台应用程序

有一个更简单的方法:

在所有活动扩展的BaseActivity上:

protected static boolean isVisible = false;

 @Override
 public void onResume()
 {
     super.onResume();
     setVisible(true);
 }


 @Override
 public void onPause()
 {
     super.onPause();
     setVisible(false);
 }

无论何时你需要检查你的应用程序活动是否在前台，只需检查isVisible();

要理解这种方法，请检查side-by-side活动生命周期的答案:activity side-by-side生命周期

当一个对话框出现在活动上方时，活动将被暂停，因此所有推荐的解决方案都是半解决方案。您还需要为对话框创建钩子。

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

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

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

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

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

参见onActivityDestroyed函数中的注释。

适用于SDK目标版本14>:

import android.app.Activity;
import android.app.Application;
import android.os.Bundle;
import android.util.Log;

public class AppLifecycleHandler implements Application.ActivityLifecycleCallbacks {

    public static int active = 0;

    @Override
    public void onActivityStopped(Activity activity) {
        Log.i("Tracking Activity Stopped", activity.getLocalClassName());
        active--;
    }

    @Override
    public void onActivityStarted(Activity activity) {
        Log.i("Tracking Activity Started", activity.getLocalClassName());
        active++;
    }

    @Override
    public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
        Log.i("Tracking Activity SaveInstanceState", activity.getLocalClassName());
    }

    @Override
    public void onActivityResumed(Activity activity) {
        Log.i("Tracking Activity Resumed", activity.getLocalClassName());
        active++;
    }

    @Override
    public void onActivityPaused(Activity activity) {
        Log.i("Tracking Activity Paused", activity.getLocalClassName());
        active--;
    }

    @Override
    public void onActivityDestroyed(Activity activity) {
        Log.i("Tracking Activity Destroyed", activity.getLocalClassName());
        active--;

        // if active var here ever becomes zero, the app is closed or in background
        if(active == 0){
            ...
        }

    }

    @Override
    public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
        Log.i("Tracking Activity Created", activity.getLocalClassName());
        active++;
    }
}