BackgroundTasks API support (#251)

Author: lucas34

Sources/SwiftQueue/JobBuilder.swift

@@ -79,11 +79,12 @@ public final class JobBuilder {
     /// Repeat job a certain number of time and with a interval between each run
     /// Limit of period to reproduce
     /// interval between each run. Does not affect the first iteration. Please add delay if so
-    public func periodic(limit: Limit = .unlimited, interval: TimeInterval = 0) -> Self {
+    public func periodic(limit: Limit = .unlimited, interval: TimeInterval = 0, allowBackground: Bool = false) -> Self {
         assert(limit.validate)
         assert(interval >= 0)
         info.maxRun = limit
         info.interval = interval
+        info.allowBackground = allowBackground
         return self
     }
 

Sources/SwiftQueue/JobInfo.swift

@@ -38,7 +38,7 @@ public struct JobInfo {
     /// Override job when scheduling a job with same uuid
     var override: Bool
 
-    //// Including job that are executing when scheduling with same uuid
+    /// Including job that are executing when scheduling with same uuid
     var includeExecutingJob: Bool
 
     /// Set of identifiers
@@ -65,6 +65,9 @@ public struct JobInfo {
     /// Time between each repetition of the job
     var interval: TimeInterval
 
+    /// Allow job to run in background task
+    var allowBackground: Bool
+
     /// Number of run maximum
     var maxRun: Limit
 
@@ -131,6 +134,7 @@ public struct JobInfo {
                 createTime: Date(),
                 interval: -1.0,
                 maxRun: .limited(0),
+                allowBackground: false,
                 retries: .limited(0),
                 runCount: 0,
                 requireCharging: false,
@@ -154,6 +158,7 @@ public struct JobInfo {
                   createTime: Date,
                   interval: TimeInterval,
                   maxRun: Limit,
+                  allowBackground: Bool,
                   retries: Limit,
                   runCount: Double,
                   requireCharging: Bool,
@@ -176,6 +181,7 @@ public struct JobInfo {
         self.createTime = createTime
         self.interval = interval
         self.maxRun = maxRun
+        self.allowBackground = allowBackground
         self.retries = retries
         self.runCount = runCount
         self.requireCharging = requireCharging

Sources/SwiftQueue/JobInfoSerializer+Decodable.swift

@@ -74,6 +74,7 @@ extension JobInfo: Decodable {
         case createTime = "createTime"
         case interval = "runCount"
         case maxRun = "maxRun"
+        case allowBackground = "allowBackground"
         case retries = "retries"
         case runCount = "interval"
         case requireCharging = "requireCharging"
@@ -99,6 +100,7 @@ extension JobInfo: Decodable {
         let createTime: Date = try container.decode(Date.self, forKey: .createTime)
         let interval: TimeInterval = try container.decode(TimeInterval.self, forKey: .interval)
         let maxRun: Limit = try container.decode(Limit.self, forKey: .maxRun)
+        let allowBackground: Bool = try container.decode(Bool.self, forKey: .allowBackground)
         let retries: Limit = try container.decode(Limit.self, forKey: .retries)
         let runCount: Double = try container.decode(Double.self, forKey: .runCount)
         let requireCharging: Bool = try container.decode(Bool.self, forKey: .requireCharging)
@@ -121,6 +123,7 @@ extension JobInfo: Decodable {
                 createTime: createTime,
                 interval: interval,
                 maxRun: maxRun,
+                allowBackground: allowBackground,
                 retries: retries,
                 runCount: runCount,
                 requireCharging: requireCharging,
@@ -149,6 +152,7 @@ extension JobInfo: Encodable {
         try container.encode(createTime, forKey: .createTime)
         try container.encode(interval, forKey: .interval)
         try container.encode(maxRun, forKey: .maxRun)
+        try container.encode(allowBackground, forKey: .allowBackground)
         try container.encode(retries, forKey: .retries)
         try container.encode(runCount, forKey: .runCount)
         try container.encode(requireCharging, forKey: .requireCharging)

Sources/SwiftQueue/JobInfoSerializer+V1.swift

@@ -91,6 +91,7 @@ internal extension JobInfo {
         dict[JobInfoKeys.params.stringValue]              = self.params
         dict[JobInfoKeys.createTime.stringValue]          = dateFormatter.string(from: self.createTime)
         dict[JobInfoKeys.runCount.stringValue]            = self.runCount
+        dict[JobInfoKeys.allowBackground.stringValue]     = self.allowBackground
         dict[JobInfoKeys.maxRun.stringValue]              = self.maxRun.rawValue
         dict[JobInfoKeys.retries.stringValue]             = self.retries.rawValue
         dict[JobInfoKeys.interval.stringValue]            = self.interval
@@ -114,6 +115,7 @@ internal extension JobInfo {
         dictionary.assign(JobInfoKeys.createTime.stringValue, &self.createTime, dateFormatter.date)
         dictionary.assign(JobInfoKeys.interval.stringValue, &self.interval)
         dictionary.assign(JobInfoKeys.maxRun.stringValue, &self.maxRun, Limit.fromRawValue)
+        dictionary.assign(JobInfoKeys.allowBackground.stringValue, &self.allowBackground)
         dictionary.assign(JobInfoKeys.retries.stringValue, &self.retries, Limit.fromRawValue)
         dictionary.assign(JobInfoKeys.runCount.stringValue, &self.runCount)
         dictionary.assign(JobInfoKeys.requireCharging.stringValue, &self.requireCharging)

Sources/SwiftQueue/SqOperation.swift

@@ -38,6 +38,8 @@ internal final class SqOperation: Operation {
 
     let dispatchQueue: DispatchQueue
 
+    var nextRunSchedule: Date? = nil
+
     override var name: String? { get { return info.uuid } set { } }
     override var queuePriority: QueuePriority { get { return info.priority } set { } }
     override var qualityOfService: QualityOfService { get { return info.qualityOfService } set { } }
@@ -225,6 +227,7 @@ extension SqOperation: JobResult {
         }
 
         // Schedule run after interval
+        nextRunSchedule = Date().addingTimeInterval(info.interval)
         dispatchQueue.runAfter(info.interval, callback: { [weak self] in
             self?.info.runCount += 1
             self?.run()
@@ -259,6 +262,7 @@ extension SqOperation {
 extension SqOperation {
 
     fileprivate func retryInBackgroundAfter(_ delay: TimeInterval) {
+        nextRunSchedule = Date().addingTimeInterval(delay)
         dispatchQueue.runAfter(delay) { [weak self] in
             self?.info.retries.decreaseValue(by: 1)
             self?.run()

Sources/SwiftQueue/SwiftQueueManager.swift

@@ -118,7 +118,25 @@ public final class SwiftQueueManager {
         }
         return count
     }
+}
+
+internal extension SwiftQueueManager {
+
+    func getAllAllowBackgroundOperation() -> [SqOperation] {
+        return manage.values
+                .flatMap { $0.operations }
+                .compactMap { $0 as? SqOperation }
+                .filter { $0.info.allowBackground }
+    }
 
+    func getOperation(forUUID: String) -> SqOperation? {
+        for queue: SqOperationQueue in manage.values {
+            for operation in queue.operations where operation.name == forUUID {
+                return operation as? SqOperation
+            }
+        }
+        return nil
+    }
 }
 
 internal struct SqManagerParams {
@@ -220,6 +238,7 @@ public final class SwiftQueueManagerBuilder {
         params.dispatchQueue = dispatchQueue
         return self
     }
+
     /// Get an instance of `SwiftQueueManager`
     public func build() -> SwiftQueueManager {
         return SwiftQueueManager(params: params, isSuspended: isSuspended)

Sources/ios/SwiftQueueManager+BackgroundTask.swift

@@ -0,0 +1,99 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2017 Lucas Nelaupe
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#if canImport(BackgroundTasks)
+import BackgroundTasks
+#endif
+
+@available(iOS 13.0, *)
+/// Extension of SwiftQueueManager to support BackgroundTask API from iOS 13.
+public extension SwiftQueueManager {
+
+    /// Register task that can potentially run in Background (Using BackgroundTask API)
+    /// Registration of all launch handlers must be complete before the end of applicationDidFinishLaunching(_:)
+    /// https://developer.apple.com/documentation/backgroundtasks/bgtaskscheduler/3180427-register
+    func registerForBackgroundTask(forTaskWithUUID: String) {
+        BGTaskScheduler.shared.register(forTaskWithIdentifier: forTaskWithUUID, using: nil) { [weak self] task in
+            if let operation = self?.getOperation(forUUID: task.identifier) {
+                task.expirationHandler = {
+                    operation.done(.fail(SwiftQueueError.timeout))
+                }
+                operation.handler.onRun(callback: TaskJobResult(actual: operation, task: task))
+            }
+        }
+    }
+
+    /// Call this method when application is entering background to schedule jobs as background task
+    func applicationDidEnterBackground() {
+        for operation in getAllAllowBackgroundOperation() {
+            operation.scheduleBackgroundTask()
+        }
+    }
+
+    /// Cancel all possible background Task
+    func cancelAllBackgroundTask() {
+        for operation in getAllAllowBackgroundOperation() {
+            BGTaskScheduler.shared.cancel(taskRequestWithIdentifier: operation.info.uuid)
+        }
+    }
+}
+
+@available(iOS 13.0, *)
+internal extension SqOperation {
+
+    func scheduleBackgroundTask() {
+        let request = BGProcessingTaskRequest(identifier: info.uuid)
+
+        request.requiresNetworkConnectivity = info.requireNetwork.rawValue > NetworkType.any.rawValue
+        request.requiresExternalPower = info.requireCharging
+        request.earliestBeginDate = nextRunSchedule
+
+        do {
+            try BGTaskScheduler.shared.submit(request)
+        } catch {
+            logger.log(.verbose, jobId: info.uuid, message: "Could not schedule BackgroundTask")
+        }
+    }
+}
+
+@available(iOS 13.0, *)
+private class TaskJobResult: JobResult {
+
+    private let task: BGTask
+    private let actual: JobResult
+
+    init(actual: JobResult, task: BGTask) {
+        self.actual = actual
+        self.task = task
+    }
+
+    public func done(_ result: JobCompletion) {
+        actual.done(result)
+
+        switch result {
+        case .success:
+            task.setTaskCompleted(success: true)
+        case .fail:
+            task.setTaskCompleted(success: false)
+        }
+    }
+}

SwiftQueue.podspec

@@ -18,6 +18,7 @@ Pod::Spec.new do |s|
   s.requires_arc = true
 
   s.source_files = 'Sources/SwiftQueue/**.swift'
+  s.ios.source_files   = 'Sources/ios/*.swift', 'Sources/SwiftQueue/**.swift'
 
   s.ios.dependency 'ReachabilitySwift', '~> 4.3'
   s.tvos.dependency 'ReachabilitySwift', '~> 4.3'

SwiftQueue.xcodeproj/project.pbxproj

@@ -33,6 +33,7 @@
 		1E68ED598FA15EF36B431571 /* Constraint+Deadline.swift in Sources */ = {isa = PBXBuildFile; fileRef = 1E68EF96F1DE038FFF94FCD8 /* Constraint+Deadline.swift */; };
 		1E68EDC2230D2FACC61E7868 /* Constraint+Delay.swift in Sources */ = {isa = PBXBuildFile; fileRef = 1E68E940C8373221E3EDC771 /* Constraint+Delay.swift */; };
 		1E68EE914B5B51CDB2BD7C4D /* Constraint+UniqueUUID.swift in Sources */ = {isa = PBXBuildFile; fileRef = 1E68E002DC39E9BBE4A0A06A /* Constraint+UniqueUUID.swift */; };
+		618E9CE4230E1F1300856158 /* SwiftQueueManager+BackgroundTask.swift in Sources */ = {isa = PBXBuildFile; fileRef = 618E9CE2230E1F1000856158 /* SwiftQueueManager+BackgroundTask.swift */; };
 		61A65B7722ABD172009AC9B7 /* Constraint+Timeout.swift in Sources */ = {isa = PBXBuildFile; fileRef = 61A65B7622ABD172009AC9B7 /* Constraint+Timeout.swift */; };
 		61A65B7822ABD175009AC9B7 /* Constraint+Timeout.swift in Sources */ = {isa = PBXBuildFile; fileRef = 61A65B7622ABD172009AC9B7 /* Constraint+Timeout.swift */; };
 		61A65B7922ABD175009AC9B7 /* Constraint+Timeout.swift in Sources */ = {isa = PBXBuildFile; fileRef = 61A65B7622ABD172009AC9B7 /* Constraint+Timeout.swift */; };
@@ -118,6 +119,7 @@
 		1E68E82C1E071C7AA1AC4BB6 /* Constraint+Network.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; name = "Constraint+Network.swift"; path = "SwiftQueue/Constraint+Network.swift"; sourceTree = "<group>"; };
 		1E68E940C8373221E3EDC771 /* Constraint+Delay.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; name = "Constraint+Delay.swift"; path = "SwiftQueue/Constraint+Delay.swift"; sourceTree = "<group>"; };
 		1E68EF96F1DE038FFF94FCD8 /* Constraint+Deadline.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; name = "Constraint+Deadline.swift"; path = "SwiftQueue/Constraint+Deadline.swift"; sourceTree = "<group>"; };
+		618E9CE2230E1F1000856158 /* SwiftQueueManager+BackgroundTask.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; name = "SwiftQueueManager+BackgroundTask.swift"; path = "ios/SwiftQueueManager+BackgroundTask.swift"; sourceTree = "<group>"; };
 		61A65B7622ABD172009AC9B7 /* Constraint+Timeout.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; name = "Constraint+Timeout.swift"; path = "SwiftQueue/Constraint+Timeout.swift"; sourceTree = "<group>"; };
 		95A210DDE517DF37DE5A7EC1 /* JobInfoSerializer+V1.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; name = "JobInfoSerializer+V1.swift"; path = "SwiftQueue/JobInfoSerializer+V1.swift"; sourceTree = "<group>"; };
 		95A2169E6968B5F155D5B612 /* JobInfoSerializer+Decodable.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; name = "JobInfoSerializer+Decodable.swift"; path = "SwiftQueue/JobInfoSerializer+Decodable.swift"; sourceTree = "<group>"; };
@@ -232,6 +234,7 @@
 		OBJ_7 /* Sources */ = {
 			isa = PBXGroup;
 			children = (
+				618E9CE2230E1F1000856158 /* SwiftQueueManager+BackgroundTask.swift */,
 				61A65B7622ABD172009AC9B7 /* Constraint+Timeout.swift */,
 				1D8479A61F82A84B00B3BBFB /* Constraint.swift */,
 				1D8479A21F82A84A00B3BBFB /* SwiftQueue.swift */,
@@ -414,6 +417,7 @@
 				D0B7C9AE1E4717DE474FD804 /* SqOperationQueue.swift in Sources */,
 				95A21FA05AABFA4A59096E8E /* SwiftQueueLogger.swift in Sources */,
 				95A21FA0723161F6908B133B /* Constraint+Charging.swift in Sources */,
+				618E9CE4230E1F1300856158 /* SwiftQueueManager+BackgroundTask.swift in Sources */,
 				95A21B7D3F013BAF87216CF0 /* JobInfoSerializer+Decodable.swift in Sources */,
 				95A215B786349300D06194AF /* JobInfoSerializer+V1.swift in Sources */,
 			);

Tests/SwiftQueueTests/SwiftQueueManagerTests.swift

@@ -197,4 +197,52 @@ class SwiftQueueManagerTests: XCTestCase {
         XCTAssertNotEqual(Limit.unlimited, Limit.limited(-1))
     }
 
+    public func testGetAllAllowBackgroundOperation() {
+        let (type, job) = (UUID().uuidString, TestJob())
+
+        let id = UUID().uuidString
+        let id2 = UUID().uuidString
+
+        let group = UUID().uuidString
+        let group2 = UUID().uuidString
+
+        let creator = TestCreator([type: job])
+
+        let persister = PersisterTracker(key: UUID().uuidString)
+
+        let manager = SwiftQueueManagerBuilder(creator: creator).set(isSuspended: true).set(persister: persister).build()
+
+        JobBuilder(type: type).periodic(allowBackground: false).parallel(queueName: group).schedule(manager: manager)
+        JobBuilder(type: type).periodic(allowBackground: false).parallel(queueName: group2).schedule(manager: manager)
+
+        JobBuilder(type: type).singleInstance(forId: id).periodic(allowBackground: true).parallel(queueName: group).schedule(manager: manager)
+        JobBuilder(type: type).singleInstance(forId: id2).periodic(allowBackground: true).parallel(queueName: group2).schedule(manager: manager)
+
+        let result = manager.getAllAllowBackgroundOperation()
+
+        XCTAssertEqual(2, result.count)
+        XCTAssertTrue([id, id2].contains(result[0].info.uuid))
+        XCTAssertTrue([id, id2].contains(result[1].info.uuid))
+    }
+
+
+    public func testGetOperation() {
+        let (type, job) = (UUID().uuidString, TestJob())
+        let id = UUID().uuidString
+        let creator = TestCreator([type: job])
+        let persister = PersisterTracker(key: UUID().uuidString)
+        let manager = SwiftQueueManagerBuilder(creator: creator).set(isSuspended: true).set(persister: persister).build()
+
+        for _ in 0..<100 {
+            JobBuilder(type: type).parallel(queueName: UUID().uuidString).schedule(manager: manager)
+        }
+
+        JobBuilder(type: type).singleInstance(forId: id).parallel(queueName: UUID().uuidString).schedule(manager: manager)
+
+        let operation = manager.getOperation(forUUID: id)
+
+        XCTAssertNotNil(operation)
+        XCTAssertEqual(id, operation?.info.uuid)
+    }
+
 }