blocks|key|1666912|text|创建一个全局变量，如private+boolean+mIsInForegroundMode;，并在onPause()中分配一个false值，在onResume()中分配一个true值。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1666913|示例代码：|1666914|private+boolean+mIsInForegroundMode;

@Override
protected+void+onPause()+{
++++super.onPause();
++++mIsInForegroundMode+=+false;
}

@Override
protected+void+onResume()+{
++++super.onResume();
++++mIsInForegroundMode+=+true;
}

//+Some+function.
public+boolean+isInForeground()+{
++++return+mIsInForegroundMode;
}|code-block|syntax|javascript|1666915|entityMap^0|A|10|1D|9|1R|5|1Z|A|2E|4|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|N|$]]

Make a global variable like <code>private boolean mIsInForegroundMode;</code> and assign a <code>false</code> value in <code>onPause()</code> and a <code>true</code> value in <code>onResume()</code>.

Sample code:

<pre><code>private boolean mIsInForegroundMode;

@Override
protected void onPause() {
 super.onPause();
 mIsInForegroundMode = false;
}

@Override
protected void onResume() {
 super.onResume();
 mIsInForegroundMode = true;
}

// Some function.
public boolean isInForeground() {
 return mIsInForegroundMode;
}
</code></pre>

blocks|key|1666953|text|或者，您可以通过getRunningTasks方法使用ActivityManager检查哪些任务正在运行。然后检查返回的任务列表中的第一个任务(前台的任务)，如果它是您的任务。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1666954|以下是代码示例：|1666955|public+Notification+buildNotification(String+arg0,+Map<String,+String>+arg1)+{

++++ActivityManager+activityManager+=+(ActivityManager)+appContext.getSystemService(Context.ACTIVITY_SERVICE);
++++List<RunningTaskInfo>+services+=+activityManager
++++++++++++.getRunningTasks(Integer.MAX_VALUE);
++++boolean+isActivityFound+=+false;

++++if+(services.get(0).topActivity.getPackageName().toString()
++++++++++++.equalsIgnoreCase(appContext.getPackageName().toString()))+{
++++++++isActivityFound+=+true;
++++}

++++if+(isActivityFound)+{
++++++++return+null;
++++}+else+{
++++++++//+write+your+code+to+build+a+notification.
++++++++//+return+the+notification+you+built+here
++++}

}|code-block|syntax|javascript|1666956|并且不要忘记在manifest.xml文件中添加GET_TASKS权限，以便能够在上面的代码中运行getRunningTasks()方法：|BOLD|1666957|<uses-permission+android:name="android.permission.GET_TASKS"+/>|1666958|p/s+:如果同意这样做，请注意此权限现在已被弃用。|1666959|entityMap^0|8|F|R|F|0|0|0|7|C|O|9|1D|H|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|10|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|11|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|12|8|@$9|13|A|14|B|O]|$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|P|3|Q|5|J|7|19|8|@]|D|@]|E|$K|L]]|$1|R|3|S|5|6|7|1A|8|@]|D|@]|E|$]]|$1|T|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]]|U|$]]

Alternately, you can check with the <code>ActivityManager</code> what tasks are running by <code>getRunningTasks</code> method. Then check with the first task(task in the foreground) in the returned List of tasks, if it is your task. Here is the code example: 

<pre><code>public Notification buildNotification(String arg0, Map&lt;String, String&gt; arg1) {

 ActivityManager activityManager = (ActivityManager) appContext.getSystemService(Context.ACTIVITY_SERVICE);
 List&lt;RunningTaskInfo&gt; services = activityManager
 .getRunningTasks(Integer.MAX_VALUE);
 boolean isActivityFound = false;

 if (services.get(0).topActivity.getPackageName().toString()
 .equalsIgnoreCase(appContext.getPackageName().toString())) {
 isActivityFound = true;
 }

 if (isActivityFound) {
 return null;
 } else {
 // write your code to build a notification.
 // return the notification you built here
 }

}
</code></pre>

And don't forget to add the <code>GET_TASKS</code> permission in the manifest.xml file in order to be able to run <code>getRunningTasks()</code> method in the above code:

<pre><code>&lt;uses-permission android:name="android.permission.GET_TASKS" /&gt;
</code></pre>

p/s : If agree this way, please to note that this permission now is deprecated.

blocks|key|2187445|text|根据Gadenkan的回复，我需要这样的东西，这样我就可以知道我的应用程序是否在前台运行，但我需要的是应用程序范围内的东西，并且不需要我在整个应用程序中设置/取消设置标志。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2187446|Gadenkan的代码几乎一针见血，但它不是我自己的风格，我觉得它可以更整洁，所以在我的应用程序中，它被压缩为以下内容。|2187447|if+(!context.getPackageName().equalsIgnoreCase(((ActivityManager)context.getSystemService(Context.ACTIVITY_SERVICE)).getRunningTasks(1).get(0).topActivity.getPackageName()))
{
//+App+is+not+in+the+foreground
}|code-block|syntax|javascript|2187448|(附注:您只需删除！如果您希望支票以相反的方式工作)|2187449|不过，使用这种方法时，您需要GET_TASKS权限。|offset|length|style|CODE|2187450|entityMap^0|0|0|0|0|E|9|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|W|8|@$M|X|N|Y|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Following up on Gadenkan's reply I needed something like this so I could tell if my app wasn't running in the foreground, but I needed something that was app wide and didn't require me setting/unsetting flags throughout my application.

Gadenkan's code pretty much hit the nail on the head but it wasn't in my own style and felt it could be tidier, so in my app its condensed down to this.

<pre><code>if (!context.getPackageName().equalsIgnoreCase(((ActivityManager)context.getSystemService(Context.ACTIVITY_SERVICE)).getRunningTasks(1).get(0).topActivity.getPackageName()))
{
// App is not in the foreground
}
</code></pre>

(Side note: You can just remove the ! if you want the check to work the other way around)

Although with this approach you need the <code>GET_TASKS</code> permission.

blocks|key|1667026|text|仅供参考，如果您使用Gadenkan解决方案(这很棒！)别忘了添加|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1667027|<uses-permission+android:name="android.permission.GET_TASKS"+/>|code-block|syntax|javascript|1667028|到货单上。|1667029|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

FYI, if you use Gadenkan solution (which is great!!) don't forget to add

<pre><code>&lt;uses-permission android:name="android.permission.GET_TASKS" /&gt;
</code></pre>

to the manifest.

blocks|key|46609|text|稍微清理了Gadenkan's+solution版本。将它放入任何活动，或者可能是所有活动的基类。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|46610|protected+boolean+isRunningInForeground()+{
++++ActivityManager+manager+=+
+++++++++(ActivityManager)+getSystemService(Context.ACTIVITY_SERVICE);
++++List<ActivityManager.RunningTaskInfo>+tasks+=+manager.getRunningTasks(1);
++++if+(tasks.isEmpty())+{
++++++++return+false;
++++}
++++String+topActivityName+=+tasks.get(0).topActivity.getPackageName();
++++return+topActivityName.equalsIgnoreCase(getPackageName());
}|code-block|syntax|javascript|46611|为了能够调用getRunningTasks()，您需要在AndroidManifest.xml中添加以下内容|style|CODE|46612|<uses-permission+android:name="android.permission.GET_TASKS"/>|46613|请注意ActivityManager.getRunningTasks()+Javadoc所说的话：|46614|46615|+注意:此方法仅用于调试和显示任务管理用户界面。此方法不应用于应用程序中的核心逻辑，例如根据此处找到的信息来决定不同的行为。这样的使用是不受支持的，并且很可能会在未来中断。|blockquote|BOLD|46616|46617|46618|更新(2015年2月)|46619|请注意，在21级中，getRunningTasks()已被弃用！|46620|从LOLLIPOP开始，此方法不再适用于第三方应用程序:以文档为中心的最新版本的引入意味着它可能会将人员信息泄露给调用者。为了向后兼容，它仍将返回其数据的一小部分:至少是调用者自己的任务，可能还有一些已知不敏感的其他任务，如home。|46621|46622|所以我之前写的更有意义：|46623|在许多情况下，你可能会想出一个更好的解决方案。例如，在onPause()和onResume()中执行某些操作，可能是在BaseActivity中执行所有活动。|46624|(在我们的示例中，我们不希望在不在前台的情况下启动离线警报活动，因此在BaseActivity+onPause()中，我们只需取消订阅RxJava+Subscription监听“已离线”信号。)|46625|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/11030799/56285|1|http://developer.android.com/reference/android/app/ActivityManager.html#getRunningTasks%2528int%2529^0|5|J|0|0|0|6|H|S|J|0|0|3|X|3|X|1|0|0|1|N|0|0|0|0|A|H|T|3|0|0|39|1|8|0|0|0|C|0|0|27|R|9|11|A|0|0|2P|1C|9|22|C|0^^$0|@$1|2|3|4|5|6|7|1K|8|@]|9|@$A|1L|B|1M|1|1N]]|C|$]]|$1|D|3|E|5|F|7|1O|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|1P|8|@$A|1Q|B|1R|K|L]|$A|1S|B|1T|K|L]]|9|@]|C|$]]|$1|M|3|N|5|F|7|1U|8|@]|9|@]|C|$G|H]]|$1|O|3|P|5|6|7|1V|8|@$A|1W|B|1X|K|L]]|9|@$A|1Y|B|1Z|1|20]]|C|$]]|$1|Q|3|-4|5|6|7|21|8|@]|9|@]|C|$]]|$1|R|3|S|5|T|7|22|8|@$A|23|B|24|K|U]]|9|@]|C|$]]|$1|V|3|-4|5|6|7|25|8|@]|9|@]|C|$]]|$1|W|3|-4|5|6|7|26|8|@]|9|@]|C|$]]|$1|X|3|Y|5|6|7|27|8|@]|9|@]|C|$]]|$1|Z|3|10|5|6|7|28|8|@$A|29|B|2A|K|L]|$A|2B|B|2C|K|U]]|9|@]|C|$]]|$1|11|3|12|5|6|7|2D|8|@$A|2E|B|2F|K|U]|$A|2G|B|2H|K|L]]|9|@]|C|$]]|$1|13|3|-4|5|6|7|2I|8|@]|9|@]|C|$]]|$1|14|3|15|5|6|7|2J|8|@$A|2K|B|2L|K|U]]|9|@]|C|$]]|$1|16|3|17|5|6|7|2M|8|@$A|2N|B|2O|K|U]|$A|2P|B|2Q|K|L]|$A|2R|B|2S|K|L]]|9|@]|C|$]]|$1|18|3|19|5|6|7|2T|8|@$A|2U|B|2V|K|U]|$A|2W|B|2X|K|L]|$A|2Y|B|2Z|K|L]]|9|@]|C|$]]|$1|1A|3|-4|5|6|7|30|8|@]|9|@]|C|$]]]|1B|$1C|$5|1D|1E|1F|C|$1G|1H]]|1I|$5|1D|1E|1F|C|$1G|1J]]]]

Slightly cleaned up version of <a href="https://stackoverflow.com/a/11030799/56285">Gadenkan's solution</a>. Put it any Activity, or maybe a base class for all your Activities.

<pre><code>protected boolean isRunningInForeground() {
 ActivityManager manager = 
 (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
 List&lt;ActivityManager.RunningTaskInfo&gt; tasks = manager.getRunningTasks(1);
 if (tasks.isEmpty()) {
 return false;
 }
 String topActivityName = tasks.get(0).topActivity.getPackageName();
 return topActivityName.equalsIgnoreCase(getPackageName());
}
</code></pre>

To be able to call <code>getRunningTasks()</code>, you need to add this in your <code>AndroidManifest.xml</code>:

<pre><code>&lt;uses-permission android:name="android.permission.GET_TASKS"/&gt;
</code></pre>

Do note what <a href="http://developer.android.com/reference/android/app/ActivityManager.html#getRunningTasks%28int%29" rel="nofollow noreferrer"><code>ActivityManager.getRunningTasks()</code></a> Javadoc says though:

<blockquote>
 Note: this method is only intended for debugging and presenting task
 management user interfaces. This should never be used for core logic
 in an application, such as deciding between different behaviors based
 on the information found here. Such uses are not supported, and will
 likely break in the future.
</blockquote>

<h2>Update (Feb 2015)</h2>

Note that <code>getRunningTasks()</code> was deprecated in API level 21! 

<blockquote>
 As of <code>LOLLIPOP</code>, this
 method is no longer available to third party applications: the
 introduction of document-centric recents means it can leak person
 information to the caller. For backwards compatibility, it will still
 return a small subset of its data: at least the caller's own tasks,
 and possibly some other tasks such as home that are known to not be
 sensitive.
</blockquote>

So what I wrote earlier is even more relevant:

In many cases you can probably come up with a better solution. For example, doing something in <code>onPause()</code> and <code>onResume()</code>, perhaps in a BaseActivity for all your Activities. 

(In our case we didn't want an offline alert activity to be launched if we are not in the foreground, so in BaseActivity <code>onPause()</code> we simply unsubscribe from the RxJava <code>Subscription</code> listening for "went offline" signal.)

blocks|key|1667088|text|基于各种答案和评论，下面是一个更内联的版本，您可以将其添加到助手类中：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1667089|public+static+boolean+isAppInForeground(Context+context)+{
++List<RunningTaskInfo>+task+=
++++++((ActivityManager)+context.getSystemService(Context.ACTIVITY_SERVICE))
++++++++++.getRunningTasks(1);
++if+(task.isEmpty())+{
++++return+false;
++}
++return+task
++++++.get(0)
++++++.topActivity
++++++.getPackageName()
++++++.equalsIgnoreCase(context.getPackageName());
}|code-block|syntax|javascript|1667090|正如在其他答案中提到的，您需要向AndroidManifest.xml添加以下权限。|offset|length|style|CODE|1667091|<uses-permission+android:name="android.permission.GET_TASKS"/>|1667092|entityMap^0|0|0|G|J|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Based on the various answers and comments, here is a more inlined version that you can add to a helper class:

<pre><code>public static boolean isAppInForeground(Context context) {
 List&lt;RunningTaskInfo&gt; task =
 ((ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE))
 .getRunningTasks(1);
 if (task.isEmpty()) {
 return false;
 }
 return task
 .get(0)
 .topActivity
 .getPackageName()
 .equalsIgnoreCase(context.getPackageName());
}
</code></pre>

As mentioned in other answers you need to add the following permission to your <code>AndroidManifest.xml</code> . 

<pre><code>&lt;uses-permission android:name="android.permission.GET_TASKS"/&gt;
</code></pre>

blocks|key|2187518|text|这是一个相当古老的帖子，但仍然非常相关。上述被接受的解决方案可能有效，但是错误的。As+Dianne+Hackborn+wrote:|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2187519|这些API不是应用程序的UI流的基础，而是做一些事情，比如向用户显示正在运行的应用程序，或者任务管理器，等等。|2187520|是的，在内存中有一个关于这些东西的列表。然而，它是在另一个进程中关闭的，由独立于您的进程运行的线程管理，并且您不能指望(a)及时看到做出正确的决定或(b)在您返回时有一个一致的画面。另外，关于“下一个”活动的决定总是在发生切换的时候完成，直到那个确切的点(活动状态被短暂锁定以进行切换)，我们才真正知道下一件事将是什么。|2187521|这里的实现和全局行为不能保证在未来保持不变。|2187522|正确的解决方案是实现：ActivityLifeCycleCallbacks。|2187523|这基本上需要一个应用程序类，可以在其中设置处理程序来识别应用程序中活动的状态。|2187524|entityMap|0|LINK|mutability|MUTABLE|url|https://groups.google.com/forum/#!msg/android-developers/zH-2bovZSLg/L2YM8Z1N-HwJ|1|http://developer.android.com/reference/android/app/Application.ActivityLifecycleCallbacks.html^0|15|P|0|0|0|0|0|B|Q|1|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@$A|Y|B|Z|1|10]]|C|$]]|$1|D|3|E|5|6|7|11|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|12|8|@]|9|@]|C|$]]|$1|H|3|I|5|6|7|13|8|@]|9|@]|C|$]]|$1|J|3|K|5|6|7|14|8|@]|9|@$A|15|B|16|1|17]]|C|$]]|$1|L|3|M|5|6|7|18|8|@]|9|@]|C|$]]|$1|N|3|-4|5|6|7|19|8|@]|9|@]|C|$]]]|O|$P|$5|Q|R|S|C|$T|U]]|V|$5|Q|R|S|C|$T|W]]]]

This is a pretty old post but still quite relevant. The above accepted solution may work but is wrong. <a href="https://groups.google.com/forum/#!msg/android-developers/zH-2bovZSLg/L2YM8Z1N-HwJ">As Dianne Hackborn wrote:</a>

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 such what the next thing will be.

And the implementation and global behavior here is not guaranteed to remain the same in the future.

The correct solution is to implement : <a href="http://developer.android.com/reference/android/app/Application.ActivityLifecycleCallbacks.html">ActivityLifeCycleCallbacks</a>.

This basically needs an Application Class and the handler can be set in there to identify the state of your activities in the app.

blocks|key|1667165|text|我想补充的是，比起在创建通知之前检查应用程序是否在后台，更安全的方法是分别禁用和启用广播接收器onPause()和onResume()。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1667166|此方法在实际应用程序逻辑中为您提供了更多的控制，并且在将来不太可能发生变化。|1667167|@Override
protected+void+onPause()+{
++++unregisterReceiver(mHandleMessageReceiver);
++++super.onPause();
}

@Override
protected+void+onResume()+{
++++super.onResume();
++++registerReceiver(mHandleMessageReceiver,+new+IntentFilter(DISPLAY_MESSAGE_ACTION));
}|code-block|syntax|javascript|1667168|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I would like to add that a safer way to do this - than checking if your app is in the background before creating a notification - is to just disable and enable the Broadcast Receiver onPause() and onResume() respectively.

This method gives you more control in the actual application logic and is not likely to change in the future. 

<pre><code>@Override
protected void onPause() {
 unregisterReceiver(mHandleMessageReceiver);
 super.onPause();
}

@Override
protected void onResume() {
 super.onResume();
 registerReceiver(mHandleMessageReceiver, new IntentFilter(DISPLAY_MESSAGE_ACTION));
}
</code></pre>

blocks|key|3737730|text|通过将活动映射到布尔值，我找到了一种更简单、更准确的方法来检查应用程序是在前台还是在后台。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3737731|查看完整的gist+here|offset|length|3737732|entityMap|0|LINK|mutability|MUTABLE|url|https://gist.github.com/mipreamble/10d14108c3daf5dcabef#file-app_fore_back_lifecycle_callbacks^0|0|A|4|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

I found a more simpler and accurate way to check if the application is in foreground or background by mapping the activities to boolean.

Check the complete gist <a href="https://gist.github.com/mipreamble/10d14108c3daf5dcabef#file-app_fore_back_lifecycle_callbacks" rel="nofollow" title="Application foreground or background">here</a>

blocks|key|1667222|text|这没有全局回调，但对于每个活动，它都是onStop()。你不需要弄乱一个原子int。只需在每个活动中使用一个全局整数，在onStart()中递增它，在onStop()中递减它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1667223|关注this|offset|length|1667224|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/29574425/3758898^0|0|2|4|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

There is no global callback for this, but for each activity it is onStop(). You don't need to mess with an atomic int. Just have a global int with the number of started activities, in every activity increment it in onStart() and decrement it in onStop().

Follow <a href="https://stackoverflow.com/a/29574425/3758898">this</a>

blocks|key|46878|text|只有当你想在你的活动开始时执行一些动作，并且你想要检查应用程序是在前台还是后台时，这才是有用的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|46879|除了使用活动管理器，还有一个简单的技巧，您可以通过代码来完成。如果您仔细观察活动周期，则两个活动之间以及从前景到背景的流程如下所示。假设A和B是两个活动。|46880|从A转换到B时:+1.调用A的onPause()+2.调用B的onResume()+3.完全恢复B时调用A的onStop()|46881|app进入后台时:+1.调用A的onPause()+2.调用A的onStop()|46882|您只需在activity中添加一个标记，即可检测到您的背景事件。|46883|创建一个抽象的活动，并从其他活动中扩展它，这样您就不必在需要后台事件的任何地方复制粘贴所有其他活动的代码。|46884|在抽象活动中创建标志isAppInBackground。|46885|在onCreate()方法中:+isAppInBackground+=+false；|46886|在onPause()方法中:+isAppInBackground+=+false；|46887|在onStop()方法中:+isAppInBackground+=+true；|46888|如果isAppInBackground为真，您只需要签入您的onResume()。N检查标志后，再次设置isAppInBackground+=+false|46889|对于两个活动之间的转换，因为first的onSTop()总是在第二个activity恢复后调用，标志永远不会为真，当应用程序在后台时，activity的onStop()将在onPause之后立即调用，因此当您稍后打开应用程序时，标志将为真。|46890|不过，在这种方法中还有一个场景。如果您的任何应用程序屏幕已经打开，并且您将移动设备设置为空闲，那么一段时间后，移动设备将进入睡眠模式，当您解锁移动设备时，它将在后台事件中处理。|46891|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|12|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|13|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|14|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|15|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|16|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|17|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|18|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|19|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|1A|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|1B|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|1C|8|@]|9|@]|A|$]]|$1|X|3|Y|5|6|7|1D|8|@]|9|@]|A|$]]|$1|Z|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|10|$]]

This is useful only when you want to perform some action just when your activity starts and its where you want to check if app is in foreground or background.

Instead of using Activity manager there is a simple trick which you can do through code.
If you observe the activity cycle closely, the flow between two activities and foreground to background is as follows.
Suppose A and B are two activities.

When transition from A to B:
 1. onPause() of A is called
 2. onResume() of B is called
 3. onStop() of A is called when B is fully resumed

When app goes into background:
 1. onPause() of A is called
 2. onStop() of A is called

You can detect your background event by simply putting a flag in activity.

Make an abstract activity and extend it from your other activities, so that you wont have to copy paste the code for all other activities wherever you need background event.

In abstract activity create flag isAppInBackground.

In onCreate() method: 
 isAppInBackground = false;

In onPause() method:
 isAppInBackground = false;

In onStop() method:
 isAppInBackground = true;

You just to need to check in your onResume() if isAppInBackground is true.
n after you check your flag then again set isAppInBackground = false

For transition between two activities since onSTop() of first will always called after second actvity resumes, flag will never be true and when app is in background, onStop() of activity will be called immediately after onPause and hence the flag will be true when you open the app later on.

There is one more scenario though in this approach.
If any of your app screen is already open and you put the mobile idle then after some time mobile will go into sleep mode and when you unlock mobile, it will be treated at background event.

blocks|key|46935|text|这是上面@user2690455描述的简单解决方案的代码。尽管它看起来有点冗长，但总体来说它实际上是相当轻量级的|type|unstyled|depth|inlineStyleRanges|entityRanges|data|46936|在我的例子中，我们也使用AppCompatActivity，所以我必须有两个基类。|46937|public+class+BaseActivity+extends+Activity+{

++++/**
+++++*+Let+field+be+set+only+in+base+class
+++++*+All+callers+must+use+accessors,
+++++*+and+then+it's+not+up+to+them+to+manage+state.
+++++*
+++++*+Making+it+static+since+..
+++++*+1.+It+needs+to+be+used+across+two+base+classes
+++++*+2.+It's+a+singleton+state+in+the+app
+++++*/
++++private+static+boolean+IS_APP_IN_BACKGROUND+=+false;

++++@Override
++++protected+void+onResume()+{
++++++++super.onResume();

++++++++BaseActivity.onResumeAppTracking(this);

++++++++BaseActivity.setAppInBackgroundFalse();
++++}

++++@Override
++++protected+void+onStop()+{
++++++++super.onStop();

++++++++BaseActivity.setAppInBackgroundTrue();
++++}

++++@Override
++++protected+void+onPause()+{
++++++++super.onPause();

++++++++BaseActivity.setAppInBackgroundFalse();
++++}

++++protected+static+void+onResumeAppTracking(Activity+activity)+{

++++++++if+(BaseActivity.isAppInBackground())+{

++++++++++++//+do+requirements+for+returning+app+to+foreground
++++++++}

++++}

++++protected+static+void+setAppInBackgroundFalse()+{

++++++++IS_APP_IN_BACKGROUND+=+false;
++++}

++++protected+static+void+setAppInBackgroundTrue()+{

++++++++IS_APP_IN_BACKGROUND+=+true;
++++}

++++protected+static+boolean+isAppInBackground()+{

++++++++return+IS_APP_IN_BACKGROUND;
++++}
}|code-block|syntax|javascript|46938|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Here's the code for nice simple solution described above by @user2690455 . Although it looks a bit verbose, you'll see overall it's actually quite light-weight

In my case we also use AppCompatActivity, so I had to have 2 base classes.

<pre><code>public class BaseActivity extends Activity {

 /**
 * Let field be set only in base class
 * All callers must use accessors,
 * and then it's not up to them to manage state.
 *
 * Making it static since ..
 * 1. It needs to be used across two base classes
 * 2. It's a singleton state in the app
 */
 private static boolean IS_APP_IN_BACKGROUND = false;

 @Override
 protected void onResume() {
 super.onResume();

 BaseActivity.onResumeAppTracking(this);

 BaseActivity.setAppInBackgroundFalse();
 }

 @Override
 protected void onStop() {
 super.onStop();

 BaseActivity.setAppInBackgroundTrue();
 }

 @Override
 protected void onPause() {
 super.onPause();

 BaseActivity.setAppInBackgroundFalse();
 }

 protected static void onResumeAppTracking(Activity activity) {

 if (BaseActivity.isAppInBackground()) {

 // do requirements for returning app to foreground
 }

 }

 protected static void setAppInBackgroundFalse() {

 IS_APP_IN_BACKGROUND = false;
 }

 protected static void setAppInBackgroundTrue() {

 IS_APP_IN_BACKGROUND = true;
 }

 protected static boolean isAppInBackground() {

 return IS_APP_IN_BACKGROUND;
 }
}
</code></pre>

blocks|key|2184252|text|正如维奈所说，可能最好的解决方案(支持较新的安卓版本，14%2B)是在Application类实现中使用ActivityLifecycleCallbacks。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2184253|package+com.telcel.contenedor.appdelegate;

import+android.app.Activity;
import+android.app.Application.ActivityLifecycleCallbacks;
import+android.os.Bundle;

/**+Determines+global+app+lifecycle+states.+
+*+
+*+The+following+is+the+reference+of+activities+states:
+*+
+*+The+visible+lifetime+of+an+activity+happens+between+a+call+to+onStart()
+*+until+a+corresponding+call+to+onStop().+During+this+time+the+user+can+see+the
+*+activity+on-screen,+though+it+may+not+be+in+the+foreground+and+interacting+with+
+*+the+user.+The+onStart()+and+onStop()+methods+can+be+called+multiple+times,+as+
+*+the+activity+becomes+visible+and+hidden+to+the+user.
+*+
+*+The+foreground+lifetime+of+an+activity+happens+between+a+call+to+onResume()
+*+until+a+corresponding+call+to+onPause().+During+this+time+the+activity+is+in+front
+*+of+all+other+activities+and+interacting+with+the+user.+An+activity+can+frequently
+*+go+between+the+resumed+and+paused+states+--+for+example+when+the+device+goes+to
+*+sleep,+when+an+activity+result+is+delivered,+when+a+new+intent+is+delivered+--+
+*+so+the+code+in+these+methods+should+be+fairly+lightweight.+
+*+
+*+*/
public+class+ApplicationLifecycleManager+implements+ActivityLifecycleCallbacks+{

++++/**+Manages+the+state+of+opened+vs+closed+activities,+should+be+0+or+1.+
+++++*+It+will+be+2+if+this+value+is+checked+between+activity+B+onStart()+and
+++++*+activity+A+onStop().
+++++*+It+could+be+greater+if+the+top+activities+are+not+fullscreen+or+have
+++++*+transparent+backgrounds.
+++++*/
++++private+static+int+visibleActivityCount+=+0;

++++/**+Manages+the+state+of+opened+vs+closed+activities,+should+be+0+or+1
+++++*+because+only+one+can+be+in+foreground+at+a+time.+It+will+be+2+if+this+
+++++*+value+is+checked+between+activity+B+onResume()+and+activity+A+onPause().
+++++*/
++++private+static+int+foregroundActivityCount+=+0;

++++/**+Returns+true+if+app+has+foreground+*/
++++public+static+boolean+isAppInForeground(){
++++++++return+foregroundActivityCount+>+0;
++++}

++++/**+Returns+true+if+any+activity+of+app+is+visible+(or+device+is+sleep+when
+++++*+an+activity+was+visible)+*/
++++public+static+boolean+isAppVisible(){
++++++++return+visibleActivityCount+>+0;
++++}

++++public+void+onActivityCreated(Activity+activity,+Bundle+bundle)+{
++++}

++++public+void+onActivityDestroyed(Activity+activity)+{
++++}

++++public+void+onActivityResumed(Activity+activity)+{
++++++++foregroundActivityCount+%2B%2B;
++++}

++++public+void+onActivityPaused(Activity+activity)+{
++++++++foregroundActivityCount+--;
++++}


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

++++public+void+onActivityStarted(Activity+activity)+{
++++++++visibleActivityCount+%2B%2B;
++++}

++++public+void+onActivityStopped(Activity+activity)+{
++++++++visibleActivityCount+--;
++++}
}|code-block|syntax|javascript|2184254|在应用程序onCreate()方法中：|2184255|registerActivityLifecycleCallbacks(new+ApplicationLifecycleManager());|2184256|然后，将使用ApplicationLifecycleManager.isAppVisible()或ApplicationLifecycleManager.isAppInForeground()来了解所需的状态。|2184257|entityMap^0|X|B|1E|Q|0|0|5|A|0|0|6|16|1D|1B|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|12|8|@$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|R|$]]

As Vinay says, probably the best solution (to support newer android versions, 14+) is to use <code>ActivityLifecycleCallbacks</code> in the <code>Application</code> class implementation.

<pre><code>package com.telcel.contenedor.appdelegate;

import android.app.Activity;
import android.app.Application.ActivityLifecycleCallbacks;
import android.os.Bundle;

/** Determines global app lifecycle states. 
 * 
 * The following is the reference of activities states:
 * 
 * The &lt;b&gt;visible&lt;/b&gt; lifetime of an activity happens between a call to onStart()
 * until a corresponding call to onStop(). During this time the user can see the
 * activity on-screen, though it may not be in the foreground and interacting with 
 * the user. The onStart() and onStop() methods can be called multiple times, as 
 * the activity becomes visible and hidden to the user.
 * 
 * The &lt;b&gt;foreground&lt;/b&gt; lifetime of an activity happens between a call to onResume()
 * until a corresponding call to onPause(). During this time the activity is in front
 * of all other activities and interacting with the user. An activity can frequently
 * go between the resumed and paused states -- for example when the device goes to
 * sleep, when an activity result is delivered, when a new intent is delivered -- 
 * so the code in these methods should be fairly lightweight. 
 * 
 * */
public class ApplicationLifecycleManager implements ActivityLifecycleCallbacks {

 /** Manages the state of opened vs closed activities, should be 0 or 1. 
 * It will be 2 if this value is checked between activity B onStart() and
 * activity A onStop().
 * It could be greater if the top activities are not fullscreen or have
 * transparent backgrounds.
 */
 private static int visibleActivityCount = 0;

 /** Manages the state of opened vs closed activities, should be 0 or 1
 * because only one can be in foreground at a time. It will be 2 if this 
 * value is checked between activity B onResume() and activity A onPause().
 */
 private static int foregroundActivityCount = 0;

 /** Returns true if app has foreground */
 public static boolean isAppInForeground(){
 return foregroundActivityCount &gt; 0;
 }

 /** Returns true if any activity of app is visible (or device is sleep when
 * an activity was visible) */
 public static boolean isAppVisible(){
 return visibleActivityCount &gt; 0;
 }

 public void onActivityCreated(Activity activity, Bundle bundle) {
 }

 public void onActivityDestroyed(Activity activity) {
 }

 public void onActivityResumed(Activity activity) {
 foregroundActivityCount ++;
 }

 public void onActivityPaused(Activity activity) {
 foregroundActivityCount --;
 }


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

 public void onActivityStarted(Activity activity) {
 visibleActivityCount ++;
 }

 public void onActivityStopped(Activity activity) {
 visibleActivityCount --;
 }
}
</code></pre>

And in Application <code>onCreate()</code> method:

<pre><code>registerActivityLifecycleCallbacks(new ApplicationLifecycleManager());
</code></pre>

Then <code>ApplicationLifecycleManager.isAppVisible()</code> or <code>ApplicationLifecycleManager.isAppInForeground()</code> would be used to know the desired state.

blocks|key|46964|text|+++++public+static+boolean+isAppRunning(Context+context)+{

+//+check+with+the+first+task(task+in+the+foreground)
+//+in+the+returned+list+of+tasks

+++ActivityManager+activityManager+=+(ActivityManager)
+++context.getSystemService(Context.ACTIVITY_SERVICE);
+List<RunningTaskInfo>+services+=
+activityManager.getRunningTasks(Integer.MAX_VALUE);
+++++if
+++++(services.get(0).topActivity.getPackageName().toString().equalsIgnoreCase(context.getPackageName().toString()))
+++++{
+++++return+true;
+++++}
+++++return+false;
+++++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|46965|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code> public static boolean isAppRunning(Context context) {

 // check with the first task(task in the foreground)
 // in the returned list of tasks

 ActivityManager activityManager = (ActivityManager)
 context.getSystemService(Context.ACTIVITY_SERVICE);
 List&lt;RunningTaskInfo&gt; services =
 activityManager.getRunningTasks(Integer.MAX_VALUE);
 if
 (services.get(0).topActivity.getPackageName().toString().equalsIgnoreCase(context.getPackageName().toString()))
 {
 return true;
 }
 return false;
 }
</code></pre>

blocks|key|2187686|text|这里提到的前面的方法并不是最优的。基于任务的方法需要一个可能不需要的权限，而“布尔”方法容易造成并发修改混乱。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2187687|我使用的方法(我相信)在大多数情况下都运行得很好：|2187688|有一个"MainApplication“类来跟踪AtomicInteger中的活动计数|offset|length|style|BOLD|2187689|import+android.app.Application;

import+java.util.concurrent.atomic.AtomicInteger;

public+class+MainApplication+extends+Application+{
++++static+class+ActivityCounter+{
++++++++private+static+AtomicInteger+ACTIVITY_COUNT+=+new+AtomicInteger(0);

++++++++public+static+boolean+isAppActive()+{
++++++++++++return+ACTIVITY_COUNT.get()+>+0;
++++++++}

++++++++public+static+void+activityStarted()+{
++++++++++++ACTIVITY_COUNT.incrementAndGet();
++++++++}

++++++++public+static+void+activityStopped()+{
++++++++++++ACTIVITY_COUNT.decrementAndGet();
++++++++}
++++}
}|code-block|syntax|javascript|2187690|并创建一个其他活动可以扩展的基本活动类：|2187691|import+android.app.Activity;
import+android.support.annotation.CallSuper;

public+class+TestActivity+extends+Activity+{
++++@Override
++++@CallSuper
++++protected+void+onStart()+{
++++++++MainApplication.ActivityCounter.activityStarted();
++++++++super.onStart();
++++}

++++@Override
++++@CallSuper
++++protected+void+onStop()+{
++++++++MainApplication.ActivityCounter.activityStopped();
++++++++super.onStop();
++++}
}|2187692|entityMap^0|0|0|O|D|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|W|8|@$F|X|G|Y|H|I]]|9|@]|A|$]]|$1|J|3|K|5|L|7|Z|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|11|8|@]|9|@]|A|$M|N]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

The previous approaches mentioned here are not optimal. The task based approach requires a permission that might not be desired and "Boolean" approach is prone to concurrent modification mess ups.

The approach I use and which (I believe) works quite well in most cases:

Have a "MainApplication" class to track activity count in AtomicInteger:

<pre><code>import android.app.Application;

import java.util.concurrent.atomic.AtomicInteger;

public class MainApplication extends Application {
 static class ActivityCounter {
 private static AtomicInteger ACTIVITY_COUNT = new AtomicInteger(0);

 public static boolean isAppActive() {
 return ACTIVITY_COUNT.get() &gt; 0;
 }

 public static void activityStarted() {
 ACTIVITY_COUNT.incrementAndGet();
 }

 public static void activityStopped() {
 ACTIVITY_COUNT.decrementAndGet();
 }
 }
}
</code></pre>

And create a base Activity class that other activities would extend:

<pre><code>import android.app.Activity;
import android.support.annotation.CallSuper;

public class TestActivity extends Activity {
 @Override
 @CallSuper
 protected void onStart() {
 MainApplication.ActivityCounter.activityStarted();
 super.onStart();
 }

 @Override
 @CallSuper
 protected void onStop() {
 MainApplication.ActivityCounter.activityStopped();
 super.onStop();
 }
}
</code></pre>

blocks|key|2187700|text|从API+16开始，你可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2187701|static+boolean+shouldShowNotification(Context+context)+{
++++RunningAppProcessInfo+myProcess+=+new+RunningAppProcessInfo();
++++ActivityManager.getMyMemoryState(myProcess);
++++if+(myProcess.importance+!=+RunningAppProcessInfo.IMPORTANCE_FOREGROUND)
++++++++return+true;

++++KeyguardManager+km+=+(KeyguardManager)+context.getSystemService(Context.KEYGUARD_SERVICE);
++++//+app+is+in+foreground,+but+if+screen+is+locked+show+notification+anyway
++++return+km.inKeyguardRestrictedInputMode();
}|code-block|syntax|javascript|2187702|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Since API 16 you can do it like this:

<pre><code>static boolean shouldShowNotification(Context context) {
 RunningAppProcessInfo myProcess = new RunningAppProcessInfo();
 ActivityManager.getMyMemoryState(myProcess);
 if (myProcess.importance != RunningAppProcessInfo.IMPORTANCE_FOREGROUND)
 return true;

 KeyguardManager km = (KeyguardManager) context.getSystemService(Context.KEYGUARD_SERVICE);
 // app is in foreground, but if screen is locked show notification anyway
 return km.inKeyguardRestrictedInputMode();
}
</code></pre>

blocks|key|47023|text|下面是我使用的一个方法(和支持方法)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|47024|private+boolean+checkIfAppIsRunningInForeground()+{
++++ActivityManager+activityManager+=+(ActivityManager)getSystemService(Context.ACTIVITY_SERVICE);
++++for(ActivityManager.RunningAppProcessInfo+appProcessInfo+:+activityManager.getRunningAppProcesses())+{
++++++++if(appProcessInfo.processName.contains(this.getPackageName()))+{
++++++++++++return+checkIfAppIsRunningInForegroundByAppImportance(appProcessInfo.importance);
++++++++}
++++}
++++return+false;
}

private+boolean+checkIfAppIsRunningInForegroundByAppImportance(int+appImportance)+{
++++switch+(appImportance)+{
++++++++//user+is+aware+of+app
++++++++case+ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND:
++++++++case+ActivityManager.RunningAppProcessInfo.IMPORTANCE_VISIBLE:
++++++++++++return+true;
++++++++//user+is+not+aware+of+app
++++++++case+ActivityManager.RunningAppProcessInfo.IMPORTANCE_BACKGROUND:
++++++++case+ActivityManager.RunningAppProcessInfo.IMPORTANCE_EMPTY:
++++++++case+ActivityManager.RunningAppProcessInfo.IMPORTANCE_PERCEPTIBLE:
++++++++case+ActivityManager.RunningAppProcessInfo.IMPORTANCE_SERVICE:
++++++++default:
++++++++++++return+false;
++++}
}|code-block|syntax|javascript|47025|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is a method that I use (and supporting method):

<pre><code>private boolean checkIfAppIsRunningInForeground() {
 ActivityManager activityManager = (ActivityManager)getSystemService(Context.ACTIVITY_SERVICE);
 for(ActivityManager.RunningAppProcessInfo appProcessInfo : activityManager.getRunningAppProcesses()) {
 if(appProcessInfo.processName.contains(this.getPackageName())) {
 return checkIfAppIsRunningInForegroundByAppImportance(appProcessInfo.importance);
 }
 }
 return false;
}

private boolean checkIfAppIsRunningInForegroundByAppImportance(int appImportance) {
 switch (appImportance) {
 //user is aware of app
 case ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND:
 case ActivityManager.RunningAppProcessInfo.IMPORTANCE_VISIBLE:
 return true;
 //user is not aware of app
 case ActivityManager.RunningAppProcessInfo.IMPORTANCE_BACKGROUND:
 case ActivityManager.RunningAppProcessInfo.IMPORTANCE_EMPTY:
 case ActivityManager.RunningAppProcessInfo.IMPORTANCE_PERCEPTIBLE:
 case ActivityManager.RunningAppProcessInfo.IMPORTANCE_SERVICE:
 default:
 return false;
 }
}
</code></pre>

blocks|key|47070|text|从支持库版本26开始，您可以使用ProcessLifecycleOwner来确定应用程序的当前状态，只需像上述here那样将其添加到您的依赖项中，例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|47071|dependencies+{
++++def+lifecycle_version+=+"1.1.1"

++++//+ViewModel+and+LiveData
++++implementation+"android.arch.lifecycle:extensions:$lifecycle_version"
++++//+alternatively+-+Lifecycles+only+(no+ViewModel+or+LiveData).
++++//+++++Support+library+depends+on+this+lightweight+import
++++implementation+"android.arch.lifecycle:runtime:$lifecycle_version"
++++annotationProcessor+"android.arch.lifecycle:compiler:$lifecycle_version"+//+use+kapt+for+Kotlin
}|code-block|syntax|javascript|47072|，现在你可以在任何时候查询ProcessLifecycleOwner，只要你想检查app的状态，比如检查app是否在前台运行，你只需要这样做：|style|CODE|47073|+boolean+isAppInForeground+=+ProcessLifecycleOwner.get().getLifecycle().getCurrentState().isAtLeast(Lifecycle.State.STARTED);
+if(!isAppInForeground)
++++//Show+Notification+in+status+bar|47074|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.android.com/reference/android/arch/lifecycle/ProcessLifecycleOwner|1|https://developer.android.com/topic/libraries/architecture/adding-components#lifecycle^0|G|L|0|1J|4|1|0|0|D|L|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]|$A|12|B|13|1|14]]|C|$]]|$1|D|3|E|5|F|7|15|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|16|8|@$A|17|B|18|K|L]]|9|@]|C|$]]|$1|M|3|N|5|F|7|19|8|@]|9|@]|C|$G|H]]|$1|O|3|-4|5|6|7|1A|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]|W|$5|R|S|T|C|$U|X]]]]

Starting support library version 26 you can use <a href="https://developer.android.com/reference/android/arch/lifecycle/ProcessLifecycleOwner" rel="noreferrer">ProcessLifecycleOwner</a> to determine app current state, just add it to your dependencies like described <a href="https://developer.android.com/topic/libraries/architecture/adding-components#lifecycle" rel="noreferrer">here</a>, for example:

<pre><code>dependencies {
 def lifecycle_version = "1.1.1"

 // ViewModel and LiveData
 implementation "android.arch.lifecycle:extensions:$lifecycle_version"
 // alternatively - Lifecycles only (no ViewModel or LiveData).
 // Support library depends on this lightweight import
 implementation "android.arch.lifecycle:runtime:$lifecycle_version"
 annotationProcessor "android.arch.lifecycle:compiler:$lifecycle_version" // use kapt for Kotlin
}
</code></pre>

, Now you can query <code>ProcessLifecycleOwner</code> whenever you want to check app state, for example to check if app is running in foreground you just have to do this:

<pre><code> boolean isAppInForeground = ProcessLifecycleOwner.get().getLifecycle().getCurrentState().isAtLeast(Lifecycle.State.STARTED);
 if(!isAppInForeground)
 //Show Notification in status bar
</code></pre>

I am doing a status bar notification in my android app that is triggered by c2dm. I don't want to display the notification if the app is running. How do you determine if the app is running and is in the foreground?

How can I tell if Android app is running in the foreground?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我正在我的安卓应用程序中执行由c2dm触发的状态栏通知。如果应用程序正在运行，我不想显示通知。如何确定应用程序是否正在运行以及是否处于前台？

问如何判断Android应用是否在前台运行？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何判断Android应用是否在前台运行？EN