我对 iOS 状态管理的理解是，当用户点击 home 键时，应用程序变为非事件状态，然后进入后台，然后在几秒钟后暂停。如果系统需要释放内存，或者如果用户将应用从最近使用的列表中滑动，则暂停的应用将被终止。

我的问题是，有什么方法可以让我知道我的应用程序已经离开后台状态并进入暂停状态吗？我知道像 applicationDidEnterBackground 这样的应用程序委托(delegate)方法 等，但有没有办法告诉我该应用程序已暂停？我认为被停职不与被解雇是对的吗？

我问这个问题的背景是我正在创建一个音频播放器应用程序。我在 Info.plist 中启用了背景音频，因此当播放音频并按下主页按钮时，我可以看到该应用程序无限期地保留在后台(这很好)。但是，当不播放音频时，无需将应用程序保留在后台，据我所知，应用程序应该暂停。我希望能够检查这是否正在发生!

非常感谢 - 请纠正我的任何误解。

最佳答案

iOS 不会报告应用程序何时暂停(从后台进入非处理状态)，也不会在应用程序恢复后触发通知。对此存在一些混淆，因为当应用程序变为“事件”或将退出“事件”状态时会发出通知，但这并不总是所需的正确值。 iOS 应用有多种状态:

• 事件:应用程序在前台(最前面)并且没有通知或菜单拉到它上面。下拉菜单或收到外部通知或短信将导致应用程序“退出”事件状态，并在处理完警报后恢复事件状态。
• 后台:应用不在前台但仍在处理中。如果没有后台任务在运行，这会在挂起之前短暂发生，或者如果有长时间运行的后台模式(音频、位置等)正在运行，则可能是永久状态。
• 暂停:应用程序在内存中，但运行循环和处理暂停
• 已终止:应用未运行或未在内存中，已被用户(强制退出)或操作系统(以释放内存)退出或从未启动

为了捕获应用暂停的时间，您必须捕获应用进入后台的时间，并使用 backgroundTimeRemaining 等值来估计暂停发生的时间。实际暂停只能计算为运行循环处理中的“间隙”，这可以通过预定的循环计时器和减法来完成。我为此创建了一个辅助类:

https://gist.github.com/BadPirate/0a480b947744c8c0e326daa4ab479b09

import UIKit
import Foundation

internal extension Notification.Name {
    static let applicationWillSuspend = Notification.Name("application-will-suspend")
    /// This notification gets called after the fact, but the `object` parameter is set to the `Date` of when the suspend occurred
    static let applicationDidSuspend = Notification.Name("application-did-suspend")
    static let applicationDidUnsuspend = Notification.Name("application-did-unsuspend")
    static let suspendStatusRecorderFailed = Notification.Name("suspend-status-recorder-failed")
}

internal class SuspendStatusRecorder {
    private var timer : Timer?
    private var task : UIBackgroundTaskIdentifier = UIBackgroundTaskIdentifier.invalid

    /// Start monitoring for suspend
    /// - parameter stallThreshold: Number of seconds of no processing before reporting a stall event
    internal func start() {
        stop() // If already going.
        startTask()
        let timer = Timer(timeInterval: 1, repeats: true) { [weak self] (_) in
            self?.checkStatus()
        }
        RunLoop.main.add(timer, forMode: .common)
    }

    internal func stop() {
        if let timer = timer {
            timer.invalidate()
            self.timer = nil
        }
        endTask()
    }

    private var lastPing : Int = 0
    private func willExpire() {
        endTask() // Allow app to suspend
        NotificationCenter.default.post(name: .applicationWillSuspend, object: nil)
        expectingSuspend = true
    }

    /// Set to an uptime value for when we expect our app to be suspended based on backgroundTimeRemaining
    private var expectingSuspend = false

    private func checkStatus() {
        let ping = uptime()
        if expectingSuspend {
            if ping - lastPing > 3 ||
            UIApplication.shared.applicationState == .active
            {
                // Timer stalled, either CPU failure or we were suspended.
                NotificationCenter.default.post(name: .applicationDidSuspend, object: Date(timeIntervalSinceNow: TimeInterval(lastPing - ping)))
                NotificationCenter.default.post(name: .applicationDidUnsuspend, object: nil)
                expectingSuspend = false
                startTask() // New background task so that we can make sure to catch next event
            }
        }
        lastPing = uptime()

        // In background, time is going to expire (resulting in suspend), report and end task
        if UIApplication.shared.applicationState == .background &&
           UIApplication.shared.backgroundTimeRemaining != Double.greatestFiniteMagnitude &&
           task != UIBackgroundTaskIdentifier.invalid
        {
            willExpire()
        }
    }

    private func endTask() {
        if task != UIBackgroundTaskIdentifier.invalid {
            UIApplication.shared.endBackgroundTask(task)
            self.task = UIBackgroundTaskIdentifier.invalid
        }
    }

    private func startTask() {
        task = UIApplication.shared.beginBackgroundTask(expirationHandler: { [weak self] in
            self?.willExpire()
        })
    }

    private func uptime() -> Int {
        var uptime = timespec()
        if 0 != clock_gettime(CLOCK_MONOTONIC_RAW, &uptime) {
            NotificationCenter.default.post(name: .suspendStatusRecorderFailed, object: "Could not execute clock_gettime, errno: \(errno)")
            stop()
        }
        return uptime.tv_sec
    }

    deinit {
        stop()
    }
}

关于ios - 如何判断我的应用程序是否已暂停？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/24244875/