如何判断一个Android应用程序转到后台并回到前台 - 简书
如何判断一个Android应用程序转到后台并回到前台
我们知道，当我们按返回或Home键退出应用程序的界面时，应用程序会在后台被挂起。这么设计的好处是，由于应用被系统缓存在内存中，那么在用户打开启动应用时就可以通过调用缓存，快速启动应用。当然，由于当今内存和处理器能力的限制，系统会自动关闭一些进程。那么我如何判断这个应用程序在前台还是后台，应用从后台回到前台了？看到一般都是runningProcess或者runningTasks来判断应用在前台还是后台事实上，Android在SDK 14的时候提供了一个Callback。ActivityLifecycleCallbacks，你可以通过这个Callback拿到App所有Activity的生命周期回调。看图：
public class Application extends android.app.Application {
private int activityC//activity的count数
private boolean isF//是否在前台
public void onCreate() {
super.onCreate();
registerActivityLifecycleCallbacks(new ActivityLifecycleCallbacks() {
public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
public void onActivityStarted(Activity activity) {
activityCount++;
public void onActivityResumed(Activity activity) {
public void onActivityPaused(Activity activity) {
public void onActivityStopped(Activity activity) {
activityCount--;
if(0==activityCount){
isForeground=
public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
public void onActivityDestroyed(Activity activity) {
这个Callback写在Application里的，你可以在Application初始化的时候来注册。通过这些回调我们可以将这个计数放在onStart()和onStop()中去。activityCount==1，那么就是前台，activityCount==0，那就是后台。这样判断很很简单了吧。
public abstract
class BaseClass extends AppCompatActivity {
判断当前的应用程序是不是在运行
//需要申请GETTask权限
private boolean isApplicationBroughtToBackground() {
ActivityManager am = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
List&ActivityManager.RunningTaskInfo& tasks = am.getRunningTasks(1);
if (!tasks.isEmpty()) {
ComponentName topActivity = tasks.get(0).topA
if (!topActivity.getPackageName().equals(getPackageName())) {
public boolean wasBackground=
//声明一个布尔变量,记录当前的活动背景
public void onPause(){
super.onPause();
if(isApplicationBroughtToBackground())
wasBackground=
public void onResume(){
super.onResume();
if(wasBackground){//
Log.e("aa","从后台回到前台");
wasBackground=
斯人若彩虹，遇上方知有1764人阅读
linux shell 命令
1.在下达的命令后面加上&，就可以使该命令在后台进行工作，这样做最大的好处就是不怕被ctrl+c这个中断指令所中断。&
2. 那大家可能又要问了，在后台执行的程序怎么使它恢复到前台来运行呢？很简单，只用执行fg这个命令，就可以了。&
3.可能有些同学又要问了，我现在已经在前台运行的命令，我能把它放到后台去运行么？当然可以了，只要执行ctrl+z就可以做到了。是不是很赞啊！&
4.说到这里可能有些同学又要问了，如果我有多个进程在后台运行，那如何恢复到前台来执行呢？这时候就要用到jobs这个命令了，通过jobs这个命令，能够列出所有在后台执行的进程，那个中括号（[ ]）里面的数字就是 jobs 的代号啰 ，通过fg %number 就可以恢复指定的后台进程.
& 使用nohup让程序在远程主机后台运行&
& 因为我购买的一个国外主机居然开放了Telnet权限，因此我也使用Telnet登录上去玩玩Linux，但发现一关闭窗口就自动和主机断开了，和Windows的终端不一样，所以就上网找啊找，找到了一个从后台一直运行某个程序的方法。&
& Unix/Linux下一般比如想让某个程序在后台运行，很多都是使用 & 在程序结尾来让程序自动运行。比如我们要运行mysql在后台： & /usr/local/mysql/bin/mysqld_safe –user=mysql &&
& 但是加入我们很多程序并不象mysqld一样做成守护进程，可能我们的程序只是普通程序而已，一般这种程序使用 & 结尾，但是如果终端关闭，那么程序也会被关闭。但是为了能够后台运行，那么我们就可以使用nohup这个命令，比如我们有个test.php需要在后台运行，并且希望在后台能够定期运行，那么就使用nohup： & nohup /root/test.php & & 提示：&
& [~]$ appending output to nohup.out&
& 嗯，证明运行成功，同时把程序运行的输出信息放到当前目录的 nohup.out 文件中去。 & 附：nohup命令参考 & nohup 命令&
& 用途：不挂断地运行命令。&
& 语法：nohup Command [ Arg ... ] [ & ]&
& 描述：nohup 命令运行由 Command 参数和任何相关的 Arg 参数指定的命令，忽略所有挂断（SIGHUP）信号。在注销后使用 nohup 命令运行后台中的程序。要运行后台中的 [...] & 1. 后台运行的两个命令 & 和 ctr+z & 一开始就+“&”具体方法是： [命令]空格[&] & 比如：&
& [root@pcmxexweb etc]# find / -name xml &&
& 这样，这个查找程序就会在后台运行。它运行的同时不影响你干别的事情。&
& 但是有的时候忘记了在命令之后加上,,&"符号，又不愿意停下此命令重新改写。这是可以按[ctrl+z]，把当前程序切入后台。 & [root@pcmxexweb etc]# find / -name xml & /etc/xml&
& /usr/lib64/python2.4/xml&
& /usr/share/vim/vim70/autoload/xml & /usr/share/hplip/data/xml & /usr/share/java-utils/xml & /usr/share/xml&
& /usr/share/doc/libvorbis-devel-1.1.2/xml&
& /usr/local/apache-tomcat-6.0.14/webapps/examples/jsp/xml & /webapp/web/jsp/xml&
& [root@pcmxexweb etc]# find / -name xml & /etc/xml&
& /usr/lib64/python2.4/xml&
& /usr/share/vim/vim70/autoload/xml & /usr/share/hplip/data/xml & /usr/share/java-utils/xml
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：13061次
排名：千里之外
转载：18篇
(5)(11)(5)(6)怎么将后台程序调到前台执行 - Linux/Unix当前位置:& &&&怎么将后台程序调到前台执行怎么将后台程序调到前台执行&&网友分享于：&&浏览：202次如何将后台程序调到前台执行本帖最后由 ShenDuYouLan 于
16:05:52 编辑
我的系统是嵌入式linux，我将我自己的应用程序放到启动脚本里自动后台执行了，但是我想将它调回前台如何办呢？网上说fg+进程号&&&我试了不行啊？另外我的程序是多线程程序，名字是samd&&下面的283起始那一个算我的主进程编号呢？
/ko.rel&$&ps
&&PID&&Uid&&&&&VmSize&Stat&Command
&&&&1&root&&&&&&&&360&S&&&init
&&&&2&root&&&&&&&&&&&&SWN&[ksoftirqd/0]
&&&&3&root&&&&&&&&&&&&SW&&[events/0]
&&&&4&root&&&&&&&&&&&&SW&&[khelper]
&&&&5&root&&&&&&&&&&&&SW&&[kthread]
&&&16&root&&&&&&&&&&&&SW&&[kblockd/0]
&&&32&root&&&&&&&&&&&&SW&&[pdflush]
&&&33&root&&&&&&&&&&&&SW&&[pdflush]
&&&35&root&&&&&&&&&&&&SW&&[aio/0]
&&&34&root&&&&&&&&&&&&SW&&[kswapd0]
&&114&root&&&&&&&&&&&&SW&&[mtdblockd]
&&117&root&&&&&&&&&&&&SWN&[jffs2_gcd_mtd1]
&&135&root&&&&&&&&504&S&&&-sh
&&158&root&&&&&&&&&&&&SW&&[hieth_skber]
&&260&root&&&&&&&&328&S&&&insmod&/lib/modules/2.6.14-hidmeb-release/mis
&&270&root&&&&&&&&&&&&SW&&[himci_queue]
&&278&root&&&&&&&&&&&&SW&&[mmcqd]
&&283&root&&&&&&&&780&S&&&./samd
&&284&root&&&&&&&&780&S&&&./samd
&&285&root&&&&&&&&780&S&&&./samd
&&286&root&&&&&&&&780&S&&&./samd
&&287&root&&&&&&&&780&S&&&./samd
&&288&root&&&&&&&&780&S&&&./samd
&&289&root&&&&&&&&780&S&&&./samd
&&290&root&&&&&&&&780&S&&&./samd
&&291&root&&&&&&&&780&S&&&./samd
&&292&root&&&&&&&&780&S&&&./samd
&&293&root&&&&&&&&780&S&&&./samd
&&294&root&&&&&&&&780&S&&&./samd
&&295&root&&&&&&&&780&S&&&./samd
&&296&root&&&&&&&&780&S&&&./samd
&&297&root&&&&&&&&780&S&&&./samd
&&298&root&&&&&&&&780&S&&&./samd
&&299&root&&&&&&&&780&S&&&./samd
&&300&root&&&&&&&&780&S&&&./samd
&&314&root&&&&&&&&340&R&&&ps
------解决方案--------------------引用网上说fg+进程号&&&我试了不行啊？
可能是你看错了。是作业号，不是进程号。查看作业号的命令：
jobs------解决方案--------------------1：在你的终端输入jobs命令&&&$jobs
2：找到你的程序对应的作业号&如:&[1]&&Running&&top&&&中的&1&便是top程序后台对应的作业号
3:&用&fg&+&作业号&&$&fg&1&
希望可以帮到你。------解决方案--------------------不支持，说明你的shell不支持。那就不能用了。------解决方案--------------------:~/zhangqi&&cat&sleep.sh& 共&2&页:
12345678910
12345678910
12345678910 上一篇：下一篇：文章评论相关解决方案 12345678910 Copyright & &&版权所有如何检测一个Android应用程序转到后台并回到前台-安卓android,背景background,foreground-CodeGo.net
如何检测一个Android应用程序转到后台并回到前台
我想，有没有办法来检测一个应用程序发送到后台或被推上前台写一个应用程序，并指定当它被带回前台的量呢？
本文地址 ：CodeGo.net/229693/
-------------------------------------------------------------------------------------------------------------------------
1. 该onPause()和onResume()方法被调用时，赞助商的背景和到前台再次，然而，当应用程序被启动的优先大公也被称为并且被kill之前。你可以点击这里阅读。
没有直接的方法来获取应用程序，而背景或前景，但即使我遇到这个问题，并找到了解决方案 CodeGo.net，onWindowFocusChanged和onStop。
详情点击这里
如果您的应用程序由多个活性及/或堆叠ACTIVITES像一个标签栏小工具，然后覆盖并不会工作的。即开始一个新的活动时，在创建新的人之前目前ACTIVITES会得到。精加工（使用“后退”按钮），一个活动时适用。
我发现，似乎工作通缉。
优先个需要GET_TASKS许可，由一个来检查，如果设备上的顶部运行的活动属于应用程序，包
private boolean isApplicationBroughtToBackground() {
ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
List&RunningTaskInfo& tasks = am.getRunningTasks(1);
if (!tasks.isEmpty()) {
ComponentName topActivity = tasks.get(0).topA
if (!topActivity.getPackageName().equals(context.getPackageName())) {
被发现在Droid的福（现在称为点火）
对，我已经我自己不需要GET_TASKS许可，这是很好的。相反，它是一点点
在你MainApplication类，你有轨迹在你的应用程序中运行的活动数的变量。在每个活动你增加的变量，在你减少它。
当跑步活动的人数达到0时，该应用程序放入后台如果下列条件为真：
该活动的存在不被完成（“后退”按钮这可以通过activity.isFinishing做（）
新的活动（包没有被启动。您可以覆盖的startActivity（）方法来设置一个变量，表示这个，然后重置它是在创建活动时，要运行/
当你能检测到应用程序已经辞职到后台很容易检测到它带回前台为好。
onUserLeaveHint。当您的应用程序进入后台这只会被调用。将角落案件来处理，因为它可以被称为其他原因，例如，如果打开在你的应用程序，如设置页面另一项活动，你的主要活动的将被调用，即使他们仍然在你的应用程序，轨迹到底是怎么回事在将导致错误的时候可以代替onUserLeaveHint回调而做什么你是问。
当UserLeaveHint被调用，你可以设置一个布尔inBackground标志设置为true。当被调用时，只有你回到前台，如果inBackground标志设置。这也将拜访您的主要活动，如果只是在你和从来没有离开应用程序。
如果点击该按钮，而在你设置屏幕，onUserLeaveHint将被称为在设置的活动，而当他们返回将被调用设置的活动。如果你只有这个检测代码在你的主要活动你会错过如此。有这样的代码在所有的活动，而无需复制代码，有延伸活动的抽象类的活动，并把其中的代码。然后每次有活动可以扩展这个抽象的活动。
public abstract AbstractActivity extends Activity {
private static boolean inBackground =
public void onResume() {
if (inBackground) {
// You just came from the background
inBackground =
// You just returned from another activity within your own app
public void onUserLeaveHint() {
inBackground =
public abstract MainActivity extends AbstractActivity {
public abstract SettingsActivity extends AbstractActivity {
以下是我已经成功地解决这个问题。它的工作原理的前提下活动跃迁之间的引用将最有可能提供足够的证据表明，一个应用程序已被“中背景”与否。
首先，我是一个android.app.Application实例（姑且称之为为MyApplication），其中有AAA不变来表示毫秒，从一个活动到另一个的过渡可合理地（我和2S的值）的最大数量，并一个布尔值，指示应用程序是否是“在后台”：
public class MyApplication extends Application {
private Timer mActivityTransitionT
private TimerTask mActivityTransitionTimerT
public boolean wasInB
private final long MAX_ACTIVITY_TRANSITION_TIME_MS = 2000;
本申请还提供了用于启动和停止
public void startActivityTransitionTimer() {
this.mActivityTransitionTimer = new Timer();
this.mActivityTransitionTimerTask = new TimerTask() {
public void run() {
MyApplication.this.wasInBackground =
this.mActivityTransitionTimer.schedule(mActivityTransitionTimerTask,
MAX_ACTIVITY_TRANSITION_TIME_MS);
public void stopActivityTransitionTimer() {
if (this.mActivityTransitionTimerTask != null) {
this.mActivityTransitionTimerTask.cancel();
if (this.mActivityTransitionTimer != null) {
this.mActivityTransitionTimer.cancel();
this.wasInBackground =
最后一块这种解决方案是将呼叫添加到每个从所有活动或最好的和事件，在base的活动，使所有的你的具体活动继承：
public void onResume()
super.onResume();
MyApplication myApp = (MyApplication)this.getApplication();
if (myApp.wasInBackground)
//Do specific came-here-from-background code
myApp.stopActivityTransitionTimer();
public void onPause()
super.onPause();
((MyApplication)this.getApplication()).startActivityTransitionTimer();
因此，在案件时只是你的应用程序的活动之间的导航，在离去的活动开始，但几乎所进入的新的活动取消，才可以达到最大过渡，所以wasInBackground会是假的。
在另一方面，当Activity从启动的前景，设备醒来，结束通话等，更可能在此事件之前执行的任务，wasInBackground被设置为true。
这可能会感兴趣：
ActivityLifecycleCallbacks
这不是很好，但如果你调用registerActivityLifecycleCallbacks（），你应该能够得到回调创建活动时/销毁等，您可以拨打电话进行的活动
编辑2：我已经写在下面实际并不起作用。谷歌已经拒绝了一个应用程序，包括调用ActivityManager.getRunningTasks（）。从很明显，这个API是用于调试和唯一的目的。我会尽快，因为我有一个新的更新下面的github上proejct，是几乎一样好更新这个帖子。
编辑1：我已经写了一篇博客文章，并创建了一个简单的github回购协议，使这很容易。
公认的和最受好评的答案都是不真的是最好的办法。最精彩的答案的isApplicationBroughtToBackground的（）不处理，其中应用的主要活动是屈服，是在应用程序中定义的活动情况，但具有不同的java包。我用了一个办法做到这一点，将工作在这种情况下。
调用此在，它会告诉你，如果你的应用是进入后台另一个应用程序已经开始，或者已经按下了按钮。
public static boolean isApplicationBroughtToBackground(final Activity activity) {
ActivityManager activityManager = (ActivityManager) activity.getSystemService(Context.ACTIVITY_SERVICE);
List&ActivityManager.RunningTaskInfo& tasks = activityManager.getRunningTasks(1);
// Check the top Activity against the list of Activities contained in the Application's package.
if (!tasks.isEmpty()) {
ComponentName topActivity = tasks.get(0).topA
PackageInfo pi = activity.getPackageManager().getPackageInfo(activity.getPackageName(), PackageManager.GET_ACTIVITIES);
for (ActivityInfo activityInfo : pi.activities) {
if(topActivity.getClassName().equals(activityInfo.name)) {
} catch( PackageManager.NameNotFoundException e) {
// Never happens.
退房onPause()和onResume()方法。
为了看看这个
这些问题的答案似乎并不正确。当另一个活动开始和结束也被称为。你可以做的就是保持一个全局标志（是的，全局是坏:)，并设置为true每次启动一个新的活动。它设置为false在每个活动的OnCreate。然后，在你检查这个标志。如果它是假的，您的应用程序进入后台，或者它被kill。
我所做的是确保所有的在应用程序的活动与开展startActivityForResult然后检查之前，如果不是，我们只是从我们的应用程序外返回，如果onActivityResult被调用。
boolean onActivityResultCalledBeforeOnR
public void startActivity(Intent intent) {
startActivityForResult(intent, 0);
protected void onActivityResult(int requestCode, int resultCode, Intent intent) {
super.onActivityResult(requestCode, resultCode, intent);
onActivityResultCalledBeforeOnResume =
protected void onResume() {
super.onResume();
if (!onActivityResultCalledBeforeOnResume) {
// here, app was brought to foreground
onActivityResultCalledBeforeOnResume =
警告：这是唯一的好，如果你正在开发的冰淇淋三明治（API级别14）
它可能会迟到，但有一个在冰淇淋三明治（API 14）及以上。
原来，当你的应用程序有没有更多的可见的UI，回调被触发。回调，您可以在自定义类，被称为ComponentCallbacks2（是的，有两个）。这个回调仅仅是在API级别14（冰淇淋三明治）及以上可用。
你基本上得到调用
public abstract void onTrimMemory (int level)
该等级是20或更具体地
public static final int TRIM_MEMORY_UI_HIDDEN
我一直在测试这一点，它总是工作，20级只是一个“建议”，你可能要释放资源，因为您的应用程序将不再可见。
引用官方文档：
对于onTrimMemory（INT）级别：过程已呈现的界面，并且不再这样做。大的分配与UI应该被释放在这一点上进行更好的管理。
当然，你应该这样真正做什么它说（有没有一定的明确集合，一直坐在等的概率是无止境的（参见其他可能更关键级别的官方文档）。
不过，有趣的是，操作系统告诉你：嘿，你的应用去了后台！
这是你想要的到底是什么知道摆在首位。
你怎么确定何时回来？
嗯，这很容易，我敢肯定，你有一个“BaseActivity”这样你就可以使用你的标记的事实，你回来了。只有你会说你不回来就是当你真正收到呼叫上述onTrimMemory方法。
它的工作原理。你没有得到误报。如果活动正在恢复，你回来时，如果100％的去背一遍，你就会得到一个onTrimMemory()打电话。
您需要案卷您的活动（或更好，但一个自定义类）。
保证您总是收到这个最简单的方法是创建一个简单的类是这样的：
public class MemoryBoss implements ComponentCallbacks2 {
public void onConfigurationChanged(final Configuration newConfig) {
public void onLowMemory() {
public void onTrimMemory(final int level) {
if (level == ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN) {
// We're in the Background
// you might as well implement some memory cleanup here and be a nice Android dev.
为了这一点，在你的应用程序（？你有一个，右），不喜欢：
MemoryBoss mMemoryB
public void onCreate() {
super.onCreate();
if (Build.VERSION.SDK_INT &= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
mMemoryBoss = new MemoryBoss();
registerComponentCallbacks(mMemoryBoss);
如果你创建一个Interface你可以添加一个else该if和ComponentCallbacks（不含2）在下面的API 14的任何使用。该回调只具有onLowMemory()方法，当你去到后台不会被调用，但你给它
现在启动你的应用程序，并按下你的onTrimMemory(final int level)方法应该被调用（提示：添加日志记录）。
最后一步是从回调注销。可能是最好的地方是onTerminate()您的应用程序的方法，但是，不会被调用真实设备上：
* This method is for use in emulated process environments. It will
* never be called on a production Android device, where processes are
* removed by no user code (including this callback)
* is executed when doing so.
所以，除非你真的有一个情况下，你不再希望被注册，您可以安全的忽略它，因为你的程序是死在操作系统级别反正。
如果您决定点注销（如果你，例如，您的应用程序清理和死亡提供），你可以这样做：
unregisterComponentCallbacks(mMemoryBoss);
就是这样。
我这样的解决方案：
总之，构建一个奉献的服务令每位活动报告他每个生命周期事件，以及该服务获取有关该应用程序的。
很喜欢@oldschool4664解决方案，但清洁在我看来，
在你的应用程序：
public void onCreate() {
super.onCreate();
registerActivityLifecycleCallbacks(new ActivityLifecycleCallbacks() {
public void onActivityStopped(Activity activity) {
public void onActivityStarted(Activity activity) {
public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
public void onActivityResumed(Activity activity) {
public void onActivityPaused(Activity activity) {
public void onActivityDestroyed(Activity activity) {
public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
if (activity.isTaskRoot() && !(activity instanceof SwitchActivity)) {
Log.e(HangApp.TAG, "Reload defaults on restoring from background.");
loadDefaults(new Call(3));
由马丁Marconcini答案是非常有趣和它的作品。
这是更简单，因为活动本身ComponentCallbacks2。无需创建MemoryBoss类，只覆盖onTrimMemory在你的活动和它的作品。
主要的问题是，你有当您从后台启动一个活动来得到一个特定的行为。如果重写你和方法，你就会有一个密切的答案，但不是解决办法。问题是，和方法被调用，即使你不最小化你的应用程序，他们可以当你开始一个活动，以后你按返回按钮返回到你的活动被调用。
为了消除这个问题，并知道是不是真的当从后台应用程序，你必须获得运行过程中与您的过程：
private boolean isApplicationBroughtToBackground() {
ActivityManager am = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
List&RunningTaskInfo& tasks = am.getRunningTasks(1);
if (!tasks.isEmpty()) {
ComponentName topActivity = tasks.get(0).topA
if (!topActivity.getPackageName().equals(getPackageName())) {
现在，你必须声明一个布尔变量：
public boolean wasPaused =
并要求当你的活动背景：
public void onPause(){
super.onPause();
if(isApplicationBroughtToBackground())
wasPaused =
现在，当你的活动的画面再次，问法：
public void onResume(){
super.onResume();
if(wasPaused){
lockScreen(true);
wasPaused =
这就是它。现在，当你的活动背景，后来把它给前台，锁屏就会出现。
如果你想重复这个行为你的应用程序的任何活动，你必须创建一个活动（可能是BaseActivity），并把所有的活动都从BaseActivity继承。
我希望这对您有所帮助。
本文标题 ：如何检测一个Android应用程序转到后台并回到前台
本文地址 ：CodeGo.net/229693/
Copyright (C) 2017 CodeGo.net一，工程图。二，代码。AppDelegate.hAppDelegate.mRootViewController.h#import &UIKit/UIKit.h&@interface AppDelegate : UIResponder &UIApplicationDelegate&@property (strong, nonatomic) UIWindow *@property (nonatomic, unsafe_unretained) UIBackgroundTaskIdentifier backgroundTaskI@property (nonatomic, strong) NSTimer *myT@end&RootViewController.m#import "AppDelegate.h"#import "RootViewController.h"@implementation AppDelegate- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{
self.window = [[UIWindow alloc] initWithFrame:[[UIScreen mainScreen] bounds]];
// Override point for customization after application launch.
RootViewController *rootVC=[[RootViewController alloc]init];
UINavigationController *nav=[[UINavigationController alloc]initWithRootViewController:rootVC];
self.window.rootViewController=
self.window.backgroundColor = [UIColor whiteColor];
[self.window makeKeyAndVisible];
return YES;}- (void)applicationWillResignActive:(UIApplication *)application{
// Sent when the application is about to move from active to inactive state. This can occur for certain types of temporary interruptions (such as an incoming phone call or SMS message) or when the user quits the application and it begins the transition to the background state.
// Use this method to pause ongoing tasks, disable timers, and throttle down OpenGL ES frame rates. Games should use this method to pause the game.}- (void)applicationDidEnterBackground:(UIApplication *)application{
// 使用这个方法来释放公共的资源、存储用户数据、停止我们定义的定时器（timers）、并且存储在程序终止前的相关信息。
// 如果，我们的应用程序提供了后台执行的方法，那么，在程序退出时，这个方法将代替applicationWillTerminate方法的执行。
// 标记一个长时间运行的后台任务将开始
// 通过调试，发现，iOS给了我们额外的10分钟（600s）来执行这个任务。
self.backgroundTaskIdentifier =[application beginBackgroundTaskWithExpirationHandler:^(void) {
// 当应用程序留给后台的时间快要到结束时（应用程序留给后台执行的时间是有限的）， 这个Block块将被执行
// 我们需要在次Block块中执行一些清理工作。
// 如果清理工作失败了，那么将导致程序挂掉
// 清理工作需要在主线程中用同步的方式来进行
[self endBackgroundTask];
// 模拟一个Long-Running Task
self.myTimer =[NSTimer scheduledTimerWithTimeInterval:1.0f
target:self
selector:@selector(timerMethod:)
userInfo:nil
repeats:YES];
}- (void) endBackgroundTask{
dispatch_queue_t mainQueue = dispatch_get_main_queue();
AppDelegate *weakSelf =
dispatch_async(mainQueue, ^(void) {
AppDelegate *strongSelf = weakS
if (strongSelf != nil){
[strongSelf.myTimer invalidate];// 停止定时器
// 每个对 beginBackgroundTaskWithExpirationHandler:方法的调用,必须要相应的调用 endBackgroundTask:方法。这样，来告诉应用程序你已经执行完成了。
// 也就是说,我们向 iOS 要更多时间来完成一个任务,那么我们必须告诉 iOS 你什么时候能完成那个任务。
// 也就是要告诉应用程序：&好借好还&嘛。
// 标记指定的后台任务完成
[[UIApplication sharedApplication] endBackgroundTask:self.backgroundTaskIdentifier];
// 销毁后台任务标识符
strongSelf.backgroundTaskIdentifier = UIBackgroundTaskI
});}// 模拟的一个 Long-Running Task 方法- (void) timerMethod:(NSTimer *)paramSender{
// backgroundTimeRemaining 属性包含了程序留给的我们的时间
NSTimeInterval backgroundTimeRemaining =[[UIApplication sharedApplication] backgroundTimeRemaining];
if (backgroundTimeRemaining == DBL_MAX){
//前台打印
NSLog(@"Background Time Remaining = Undetermined");
//后台打印
NSLog(@"Background Time Remaining = %.02f Seconds", backgroundTimeRemaining);
}}- (void)applicationWillEnterForeground:(UIApplication *)application{
// Called as part of the transition from the background t here you can undo many of the changes made on entering the background.
//添加此段代码，则在前台就不运行了。否则会前后台一起运行。除第一次启动的时候，是前台不运行，退出后台时候运行。
if (self.backgroundTaskIdentifier != UIBackgroundTaskInvalid){
[self endBackgroundTask];
}}- (void)applicationDidBecomeActive:(UIApplication *)application{
// Restart any tasks that were paused (or not yet started) while the application was inactive. If the application was previously in the background, optionally refresh the user interface.}- (void)applicationWillTerminate:(UIApplication *)application{
// Called when the application is about to terminate. Save data if appropriate. See also applicationDidEnterBackground:.&&&&
&函数式swift&读书笔记之Tri
最新教程周点击榜
6读书笔记之Trie结构
微信扫一扫}