|
|
|
|
@ -23,7 +23,11 @@ public enum SessionBackgroundTaskState {
|
|
|
|
|
// MARK: - SessionBackgroundTaskManager
|
|
|
|
|
|
|
|
|
|
public class SessionBackgroundTaskManager {
|
|
|
|
|
/// Maximum duration to extend background tasks
|
|
|
|
|
private static let maxBackgroundTime: TimeInterval = 180
|
|
|
|
|
|
|
|
|
|
private let dependencies: Dependencies
|
|
|
|
|
private let queue = DispatchQueue(label: "com.session.backgroundTaskManager")
|
|
|
|
|
|
|
|
|
|
/// This property should only be accessed while synchronized on this instance.
|
|
|
|
|
private var backgroundTaskId: UIBackgroundTaskIdentifier = .invalid
|
|
|
|
|
@ -43,11 +47,11 @@ public class SessionBackgroundTaskManager {
|
|
|
|
|
/// begins, we use a single uninterrupted background that spans their lifetimes.
|
|
|
|
|
///
|
|
|
|
|
/// This property should only be accessed while synchronized on this instance.
|
|
|
|
|
private var continuityTimer: Timer?
|
|
|
|
|
private var continuityTimer: DispatchSourceTimer?
|
|
|
|
|
|
|
|
|
|
/// In order to ensure we have sufficient time to clean up before background tasks expire (without having to kick off additional tasks)
|
|
|
|
|
/// we track the remaining background execution time and end tasks 5 seconds early (same as the AppDelegate background fetch)
|
|
|
|
|
private var expirationTimeObserver: Timer?
|
|
|
|
|
private var expirationTimeObserver: DispatchSourceTimer?
|
|
|
|
|
private var hasGottenValidBackgroundTimeRemaining: Bool = false
|
|
|
|
|
|
|
|
|
|
fileprivate init(using dependencies: Dependencies) {
|
|
|
|
|
@ -61,13 +65,6 @@ public class SessionBackgroundTaskManager {
|
|
|
|
|
|
|
|
|
|
// MARK: - Functions
|
|
|
|
|
|
|
|
|
|
@discardableResult private static func synced<T>(_ lock: Any, closure: () -> T) -> T {
|
|
|
|
|
objc_sync_enter(lock)
|
|
|
|
|
let result: T = closure()
|
|
|
|
|
objc_sync_exit(lock)
|
|
|
|
|
return result
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public func startObservingNotifications() {
|
|
|
|
|
guard dependencies[singleton: .appContext].isMainApp else { return }
|
|
|
|
|
|
|
|
|
|
@ -86,14 +83,14 @@ public class SessionBackgroundTaskManager {
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
@objc private func applicationDidBecomeActive() {
|
|
|
|
|
SessionBackgroundTaskManager.synced(self) { [weak self] in
|
|
|
|
|
queue.sync { [weak self] in
|
|
|
|
|
self?.isAppActive = true
|
|
|
|
|
self?.ensureBackgroundTaskState()
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
@objc private func applicationWillResignActive() {
|
|
|
|
|
SessionBackgroundTaskManager.synced(self) { [weak self] in
|
|
|
|
|
queue.sync { [weak self] in
|
|
|
|
|
self?.isAppActive = false
|
|
|
|
|
self?.ensureBackgroundTaskState()
|
|
|
|
|
}
|
|
|
|
|
@ -109,7 +106,7 @@ public class SessionBackgroundTaskManager {
|
|
|
|
|
// background task, but the background task couldn't be begun.
|
|
|
|
|
// In that case expirationBlock will not be called.
|
|
|
|
|
fileprivate func addTask(expiration: @escaping () -> ()) -> UInt64? {
|
|
|
|
|
return SessionBackgroundTaskManager.synced(self) { [weak self, dependencies] in
|
|
|
|
|
return queue.sync { [weak self] () -> UInt64? in
|
|
|
|
|
let taskId: UInt64 = ((self?.idCounter ?? 0) + 1)
|
|
|
|
|
self?.idCounter = taskId
|
|
|
|
|
self?.expirationMap[taskId] = expiration
|
|
|
|
|
@ -118,18 +115,15 @@ public class SessionBackgroundTaskManager {
|
|
|
|
|
self?.expirationMap.removeValue(forKey: taskId)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
self?.continuityTimer?.invalidate()
|
|
|
|
|
self?.continuityTimer = nil
|
|
|
|
|
if self?.continuityTimer != nil {
|
|
|
|
|
self?.continuityTimer?.cancel()
|
|
|
|
|
self?.continuityTimer = nil
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Start observing the background time remaining
|
|
|
|
|
if self?.expirationTimeObserver?.isValid != true {
|
|
|
|
|
if self?.expirationTimeObserver?.isCancelled == true {
|
|
|
|
|
self?.hasGottenValidBackgroundTimeRemaining = false
|
|
|
|
|
self?.expirationTimeObserver = Timer.scheduledTimerOnMainThread(
|
|
|
|
|
withTimeInterval: 1,
|
|
|
|
|
repeats: true,
|
|
|
|
|
using: dependencies,
|
|
|
|
|
block: { _ in self?.expirationTimerDidFire() }
|
|
|
|
|
)
|
|
|
|
|
self?.checkExpirationTime(in: .seconds(1)) // Don't know the remaining time so check soon
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return taskId
|
|
|
|
|
@ -139,7 +133,7 @@ public class SessionBackgroundTaskManager {
|
|
|
|
|
fileprivate func removeTask(taskId: UInt64?) {
|
|
|
|
|
guard let taskId: UInt64 = taskId else { return }
|
|
|
|
|
|
|
|
|
|
SessionBackgroundTaskManager.synced(self) { [weak self, dependencies] in
|
|
|
|
|
queue.sync { [weak self, queue] in
|
|
|
|
|
self?.expirationMap.removeValue(forKey: taskId)
|
|
|
|
|
|
|
|
|
|
// This timer will ensure that we keep the background task active (if necessary)
|
|
|
|
|
@ -148,87 +142,93 @@ public class SessionBackgroundTaskManager {
|
|
|
|
|
// should be able to ensure background tasks by "narrowly" wrapping
|
|
|
|
|
// their core logic with a SessionBackgroundTask and not worrying about "hand off"
|
|
|
|
|
// between SessionBackgroundTasks.
|
|
|
|
|
self?.continuityTimer?.invalidate()
|
|
|
|
|
self?.continuityTimer = Timer.scheduledTimerOnMainThread(
|
|
|
|
|
withTimeInterval: 0.25,
|
|
|
|
|
using: dependencies,
|
|
|
|
|
block: { _ in self?.continuityTimerDidFire() }
|
|
|
|
|
)
|
|
|
|
|
if self?.continuityTimer != nil {
|
|
|
|
|
self?.continuityTimer?.cancel()
|
|
|
|
|
self?.continuityTimer = nil
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
self?.continuityTimer = DispatchSource.makeTimerSource(queue: queue)
|
|
|
|
|
self?.continuityTimer?.schedule(deadline: .now() + .milliseconds(250))
|
|
|
|
|
self?.continuityTimer?.setEventHandler { self?.continuityTimerDidFire() }
|
|
|
|
|
self?.continuityTimer?.resume()
|
|
|
|
|
self?.ensureBackgroundTaskState()
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Begins or end a background task if necessary.
|
|
|
|
|
/// Begins or end a background task if necessary
|
|
|
|
|
///
|
|
|
|
|
/// **Note:** Should only be called internally within `queue.sync` for thread safety
|
|
|
|
|
@discardableResult private func ensureBackgroundTaskState() -> Bool {
|
|
|
|
|
// We can't create background tasks in the SAE, but pretend that we succeeded.
|
|
|
|
|
guard dependencies[singleton: .appContext].isMainApp else { return true }
|
|
|
|
|
|
|
|
|
|
return SessionBackgroundTaskManager.synced(self) { [weak self, dependencies] in
|
|
|
|
|
// We only want to have a background task if we are:
|
|
|
|
|
// a) "not active" AND
|
|
|
|
|
// b1) there is one or more active instance of SessionBackgroundTask OR...
|
|
|
|
|
// b2) ...there _was_ an active instance recently.
|
|
|
|
|
let shouldHaveBackgroundTask: Bool = (
|
|
|
|
|
self?.isAppActive == false && (
|
|
|
|
|
(self?.expirationMap.count ?? 0) > 0 ||
|
|
|
|
|
self?.continuityTimer != nil
|
|
|
|
|
)
|
|
|
|
|
// We only want to have a background task if we are:
|
|
|
|
|
// a) "not active" AND
|
|
|
|
|
// b1) there is one or more active instance of SessionBackgroundTask OR...
|
|
|
|
|
// b2) ...there _was_ an active instance recently.
|
|
|
|
|
let shouldHaveBackgroundTask: Bool = (
|
|
|
|
|
self.isAppActive == false && (
|
|
|
|
|
self.expirationMap.count > 0 ||
|
|
|
|
|
self.continuityTimer != nil
|
|
|
|
|
)
|
|
|
|
|
let hasBackgroundTask: Bool = (self?.backgroundTaskId != .invalid)
|
|
|
|
|
|
|
|
|
|
guard shouldHaveBackgroundTask != hasBackgroundTask else {
|
|
|
|
|
// Current state is correct
|
|
|
|
|
return true
|
|
|
|
|
}
|
|
|
|
|
guard !shouldHaveBackgroundTask else {
|
|
|
|
|
return (self?.startBackgroundTask() == true)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Need to end background task.
|
|
|
|
|
let maybeBackgroundTaskId: UIBackgroundTaskIdentifier? = self?.backgroundTaskId
|
|
|
|
|
self?.backgroundTaskId = .invalid
|
|
|
|
|
self?.expirationTimeObserver?.invalidate()
|
|
|
|
|
self?.expirationTimeObserver = nil
|
|
|
|
|
|
|
|
|
|
if let backgroundTaskId: UIBackgroundTaskIdentifier = maybeBackgroundTaskId, backgroundTaskId != .invalid {
|
|
|
|
|
dependencies[singleton: .appContext].endBackgroundTask(backgroundTaskId)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
)
|
|
|
|
|
let hasBackgroundTask: Bool = (self.backgroundTaskId != .invalid)
|
|
|
|
|
|
|
|
|
|
guard shouldHaveBackgroundTask != hasBackgroundTask else {
|
|
|
|
|
// Current state is correct
|
|
|
|
|
return true
|
|
|
|
|
}
|
|
|
|
|
guard !shouldHaveBackgroundTask else {
|
|
|
|
|
return (self.startOverarchingBackgroundTask() == true)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Need to end background task.
|
|
|
|
|
let maybeBackgroundTaskId: UIBackgroundTaskIdentifier? = self.backgroundTaskId
|
|
|
|
|
self.backgroundTaskId = .invalid
|
|
|
|
|
|
|
|
|
|
if self.expirationTimeObserver != nil {
|
|
|
|
|
self.expirationTimeObserver?.cancel()
|
|
|
|
|
self.expirationTimeObserver = nil
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if let backgroundTaskId: UIBackgroundTaskIdentifier = maybeBackgroundTaskId, backgroundTaskId != .invalid {
|
|
|
|
|
dependencies[singleton: .appContext].endBackgroundTask(backgroundTaskId)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return true
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Returns `false` if the background task cannot be begun.
|
|
|
|
|
private func startBackgroundTask() -> Bool {
|
|
|
|
|
/// Returns `false` if the background task cannot be begun
|
|
|
|
|
///
|
|
|
|
|
/// **Note:** Should only be called internally within `queue.sync` for thread safety
|
|
|
|
|
private func startOverarchingBackgroundTask() -> Bool {
|
|
|
|
|
guard dependencies[singleton: .appContext].isMainApp else { return false }
|
|
|
|
|
|
|
|
|
|
return SessionBackgroundTaskManager.synced(self) { [weak self, dependencies] in
|
|
|
|
|
self?.backgroundTaskId = dependencies[singleton: .appContext].beginBackgroundTask {
|
|
|
|
|
/// Supposedly `[UIApplication beginBackgroundTaskWithExpirationHandler]`'s handler
|
|
|
|
|
/// will always be called on the main thread, but in practice we've observed otherwise.
|
|
|
|
|
///
|
|
|
|
|
/// See:
|
|
|
|
|
/// https://developer.apple.com/documentation/uikit/uiapplication/1623031-beginbackgroundtaskwithexpiratio)
|
|
|
|
|
self.backgroundTaskId = dependencies[singleton: .appContext].beginBackgroundTask { [weak self] in
|
|
|
|
|
/// Supposedly `[UIApplication beginBackgroundTaskWithExpirationHandler]`'s handler
|
|
|
|
|
/// will always be called on the main thread, but in practice we've observed otherwise.
|
|
|
|
|
///
|
|
|
|
|
/// See:
|
|
|
|
|
/// https://developer.apple.com/documentation/uikit/uiapplication/1623031-beginbackgroundtaskwithexpiratio)
|
|
|
|
|
self?.queue.sync {
|
|
|
|
|
self?.backgroundTaskExpired()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// If the background task could not begin, return false to indicate that
|
|
|
|
|
return (self?.backgroundTaskId != .invalid)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// If the background task could not begin, return false to indicate that
|
|
|
|
|
return (self.backgroundTaskId != .invalid)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// **Note:** Should only be called internally within `queue.sync` for thread safety
|
|
|
|
|
private func backgroundTaskExpired() {
|
|
|
|
|
var backgroundTaskId: UIBackgroundTaskIdentifier = .invalid
|
|
|
|
|
var expirationMap: [UInt64: () -> ()] = [:]
|
|
|
|
|
let backgroundTaskId: UIBackgroundTaskIdentifier = self.backgroundTaskId
|
|
|
|
|
let expirationMap: [UInt64: () -> ()] = self.expirationMap
|
|
|
|
|
self.backgroundTaskId = .invalid
|
|
|
|
|
self.expirationMap.removeAll()
|
|
|
|
|
|
|
|
|
|
SessionBackgroundTaskManager.synced(self) { [weak self] in
|
|
|
|
|
backgroundTaskId = (self?.backgroundTaskId ?? .invalid)
|
|
|
|
|
self?.backgroundTaskId = .invalid
|
|
|
|
|
self?.expirationTimeObserver?.invalidate()
|
|
|
|
|
self?.expirationTimeObserver = nil
|
|
|
|
|
|
|
|
|
|
expirationMap = (self?.expirationMap ?? [:])
|
|
|
|
|
self?.expirationMap.removeAll()
|
|
|
|
|
if self.expirationTimeObserver != nil {
|
|
|
|
|
self.expirationTimeObserver?.cancel()
|
|
|
|
|
self.expirationTimeObserver = nil
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Supposedly `[UIApplication beginBackgroundTaskWithExpirationHandler]`'s handler
|
|
|
|
|
@ -247,33 +247,44 @@ public class SessionBackgroundTaskManager {
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private func checkExpirationTime(in interval: DispatchTimeInterval) {
|
|
|
|
|
expirationTimeObserver = DispatchSource.makeTimerSource(queue: queue)
|
|
|
|
|
expirationTimeObserver?.schedule(deadline: .now() + interval)
|
|
|
|
|
expirationTimeObserver?.setEventHandler { [weak self] in self?.expirationTimerDidFire() }
|
|
|
|
|
expirationTimeObserver?.resume()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Timer will always fire on the `queue` so no need to `queue.sync`
|
|
|
|
|
private func continuityTimerDidFire() {
|
|
|
|
|
SessionBackgroundTaskManager.synced(self) { [weak self] in
|
|
|
|
|
self?.continuityTimer?.invalidate()
|
|
|
|
|
self?.continuityTimer = nil
|
|
|
|
|
self?.ensureBackgroundTaskState()
|
|
|
|
|
}
|
|
|
|
|
continuityTimer = nil
|
|
|
|
|
ensureBackgroundTaskState()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Timer will always fire on the `queue` so no need to `queue.sync`
|
|
|
|
|
private func expirationTimerDidFire() {
|
|
|
|
|
expirationTimeObserver = nil
|
|
|
|
|
|
|
|
|
|
guard dependencies[singleton: .appContext].isMainApp else { return }
|
|
|
|
|
|
|
|
|
|
let backgroundTimeRemaining: TimeInterval = dependencies[singleton: .appContext].backgroundTimeRemaining
|
|
|
|
|
|
|
|
|
|
SessionBackgroundTaskManager.synced(self) { [weak self] in
|
|
|
|
|
// It takes the OS a little while to update the 'backgroundTimeRemaining' value so if it hasn't been updated
|
|
|
|
|
// yet then don't do anything
|
|
|
|
|
guard self?.hasGottenValidBackgroundTimeRemaining == true || backgroundTimeRemaining != .greatestFiniteMagnitude else {
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
self?.hasGottenValidBackgroundTimeRemaining = true
|
|
|
|
|
|
|
|
|
|
// If there is more than 5 seconds remaining then no need to do anything yet (plenty of time to continue running)
|
|
|
|
|
guard backgroundTimeRemaining <= 5 else { return }
|
|
|
|
|
|
|
|
|
|
// There isn't a lot of time remaining so trigger the expiration
|
|
|
|
|
self?.backgroundTaskExpired()
|
|
|
|
|
/// It takes the OS a little while to update the 'backgroundTimeRemaining' value so if it hasn't been updated yet then don't do anything
|
|
|
|
|
guard self.hasGottenValidBackgroundTimeRemaining == true || backgroundTimeRemaining != .greatestFiniteMagnitude else {
|
|
|
|
|
self.checkExpirationTime(in: .seconds(1))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
self.hasGottenValidBackgroundTimeRemaining = true
|
|
|
|
|
|
|
|
|
|
switch backgroundTimeRemaining {
|
|
|
|
|
/// There is more than 10 seconds remaining so no need to do anything yet (plenty of time to continue running)
|
|
|
|
|
case 10...: self.checkExpirationTime(in: .seconds(5))
|
|
|
|
|
|
|
|
|
|
/// There is between 5 and 10 seconds so poll more frequently just in case
|
|
|
|
|
case 5..<10: self.checkExpirationTime(in: .milliseconds(2500))
|
|
|
|
|
|
|
|
|
|
/// There isn't a lot of time remaining so trigger the expiration
|
|
|
|
|
default: self.backgroundTaskExpired()
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
@ -282,8 +293,6 @@ public class SessionBackgroundTaskManager {
|
|
|
|
|
|
|
|
|
|
public class SessionBackgroundTask {
|
|
|
|
|
private let dependencies: Dependencies
|
|
|
|
|
|
|
|
|
|
/// This property should only be accessed while synchronized on this instance
|
|
|
|
|
private var taskId: UInt64?
|
|
|
|
|
private let label: String
|
|
|
|
|
private var completion: ((SessionBackgroundTaskState) -> ())?
|
|
|
|
|
@ -308,86 +317,31 @@ public class SessionBackgroundTask {
|
|
|
|
|
|
|
|
|
|
// MARK: - Functions
|
|
|
|
|
|
|
|
|
|
@discardableResult private static func synced<T>(_ lock: Any, closure: () -> T) -> T {
|
|
|
|
|
objc_sync_enter(lock)
|
|
|
|
|
let result: T = closure()
|
|
|
|
|
objc_sync_exit(lock)
|
|
|
|
|
return result
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private func startBackgroundTask() {
|
|
|
|
|
// Make a local copy of completion to ensure that it is called exactly once
|
|
|
|
|
var completion: ((SessionBackgroundTaskState) -> ())?
|
|
|
|
|
|
|
|
|
|
self.taskId = dependencies[singleton: .backgroundTaskManager].addTask { [weak self] in
|
|
|
|
|
Threading.dispatchMainThreadSafe {
|
|
|
|
|
guard let strongSelf = self else { return }
|
|
|
|
|
|
|
|
|
|
SessionBackgroundTask.synced(strongSelf) {
|
|
|
|
|
self?.taskId = nil
|
|
|
|
|
completion = self?.completion
|
|
|
|
|
self?.completion = nil
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
completion?(.expired)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// If we didn't get a taskId then the background task could not be started so
|
|
|
|
|
// we should call the completion block with a 'couldNotStart' error
|
|
|
|
|
guard taskId == nil else { return }
|
|
|
|
|
|
|
|
|
|
SessionBackgroundTask.synced(self) { [weak self] in
|
|
|
|
|
completion = self?.completion
|
|
|
|
|
self?.completion = nil
|
|
|
|
|
taskId = dependencies[singleton: .backgroundTaskManager].addTask { [weak self] in
|
|
|
|
|
self?.taskExpired()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if completion != nil {
|
|
|
|
|
Threading.dispatchMainThreadSafe {
|
|
|
|
|
completion?(.couldNotStart)
|
|
|
|
|
}
|
|
|
|
|
if taskId == nil {
|
|
|
|
|
completion?(.couldNotStart)
|
|
|
|
|
completion = nil
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public func cancel() {
|
|
|
|
|
guard taskId != nil else { return }
|
|
|
|
|
|
|
|
|
|
// Make a local copy of completion to ensure that it is called exactly once
|
|
|
|
|
var completion: ((SessionBackgroundTaskState) -> ())?
|
|
|
|
|
|
|
|
|
|
SessionBackgroundTask.synced(self) { [weak self, dependencies] in
|
|
|
|
|
dependencies[singleton: .backgroundTaskManager].removeTask(taskId: self?.taskId)
|
|
|
|
|
completion = self?.completion
|
|
|
|
|
self?.taskId = nil
|
|
|
|
|
self?.completion = nil
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// endBackgroundTask must be called on the main thread.
|
|
|
|
|
if completion != nil {
|
|
|
|
|
Threading.dispatchMainThreadSafe {
|
|
|
|
|
completion?(.cancelled)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
dependencies[singleton: .backgroundTaskManager].removeTask(taskId: taskId)
|
|
|
|
|
completion?(.cancelled)
|
|
|
|
|
completion = nil
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private func endBackgroundTask() {
|
|
|
|
|
guard taskId != nil else { return }
|
|
|
|
|
|
|
|
|
|
// Make a local copy of completion since this method is called by `dealloc`
|
|
|
|
|
var completion: ((SessionBackgroundTaskState) -> ())?
|
|
|
|
|
|
|
|
|
|
SessionBackgroundTask.synced(self) { [weak self, dependencies] in
|
|
|
|
|
dependencies[singleton: .backgroundTaskManager].removeTask(taskId: self?.taskId)
|
|
|
|
|
completion = self?.completion
|
|
|
|
|
self?.taskId = nil
|
|
|
|
|
self?.completion = nil
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// endBackgroundTask must be called on the main thread.
|
|
|
|
|
if completion != nil {
|
|
|
|
|
Threading.dispatchMainThreadSafe {
|
|
|
|
|
completion?(.cancelled)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
cancel()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private func taskExpired() {
|
|
|
|
|
completion?(.expired)
|
|
|
|
|
completion = nil
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
Morgan Pretty
3 weeks ago
committed by
GitHub