Background execution (#100)

* #99 Implement background tasks

* #99 Add changelog

* #99 Fix some code smells

* #99 Use background tasks in room timeline controller

* #99 Move background task service into room proxy and media provider

ElementX/Sources/Services/Background/ApplicationProtocol.swift

@@ -0,0 +1,24 @@
+//
+//  ApplicationProtocol.swift
+//  ElementX
+//
+//  Created by Ismail on 28.06.2022.
+//  Copyright © 2022 Element. All rights reserved.
+//
+
+import Foundation
+import UIKit
+
+protocol ApplicationProtocol {
+    func beginBackgroundTask(expirationHandler handler: (() -> Void)?) -> UIBackgroundTaskIdentifier
+
+    func beginBackgroundTask(withName taskName: String?, expirationHandler handler: (() -> Void)?) -> UIBackgroundTaskIdentifier
+
+    func endBackgroundTask(_ identifier: UIBackgroundTaskIdentifier)
+
+    var backgroundTimeRemaining: TimeInterval { get }
+
+    var applicationState: UIApplication.State { get }
+}
+
+extension UIApplication: ApplicationProtocol {}

ElementX/Sources/Services/Background/BackgroundTaskProtocol.swift

@@ -0,0 +1,35 @@
+//
+//  BackgroundTaskProtocol.swift
+//  ElementX
+//
+//  Created by Ismail on 28.06.2022.
+//  Copyright © 2022 Element. All rights reserved.
+//
+
+import Foundation
+
+typealias BackgroundTaskExpirationHandler = (BackgroundTaskProtocol) -> Void
+
+/// BackgroundTaskProtocol is the protocol describing a background task regardless of the platform used.
+protocol BackgroundTaskProtocol: AnyObject {
+    /// Name of the background task for debug.
+    var name: String { get }
+
+    /// `true` if the background task is currently running.
+    var isRunning: Bool { get }
+
+    /// Flag indicating the background task is reusable. If reusable, `name` is the key to distinguish background tasks.
+    var isReusable: Bool { get }
+
+    /// Elapsed time after the task started. In milliseconds.
+    var elapsedTime: TimeInterval { get }
+
+    /// Expiration handler for the background task
+    var expirationHandler: BackgroundTaskExpirationHandler? { get }
+
+    /// Method to be called when a task reused one more time. Should only be valid for reusable tasks.
+    func reuse()
+
+    /// Stop the background task. Cannot be started anymore. For reusable tasks, should be called same number of times `reuse` called.
+    func stop()
+}

ElementX/Sources/Services/Background/BackgroundTaskServiceProtocol.swift

@@ -0,0 +1,40 @@
+//
+//  BackgroundTaskServiceProtocol.swift
+//  ElementX
+//
+//  Created by Ismail on 28.06.2022.
+//  Copyright © 2022 Element. All rights reserved.
+//
+
+import Foundation
+
+protocol BackgroundTaskServiceProtocol {
+
+    func startBackgroundTask(withName name: String,
+                             isReusable: Bool,
+                             expirationHandler: (() -> Void)?) -> BackgroundTaskProtocol?
+
+}
+
+extension BackgroundTaskServiceProtocol {
+
+    func startBackgroundTask(withName name: String) -> BackgroundTaskProtocol? {
+        return startBackgroundTask(withName: name,
+                                   expirationHandler: nil)
+    }
+
+    func startBackgroundTask(withName name: String,
+                             isReusable: Bool) -> BackgroundTaskProtocol? {
+        return startBackgroundTask(withName: name,
+                                   isReusable: isReusable,
+                                   expirationHandler: nil)
+    }
+
+    func startBackgroundTask(withName name: String,
+                             expirationHandler: (() -> Void)?) -> BackgroundTaskProtocol? {
+        return startBackgroundTask(withName: name,
+                                   isReusable: false,
+                                   expirationHandler: expirationHandler)
+    }
+
+}

ElementX/Sources/Services/Background/UIKitBackgroundTask.swift

@@ -0,0 +1,95 @@
+//
+//  UIKitBackgroundTask.swift
+//  ElementX
+//
+//  Created by Ismail on 28.06.2022.
+//  Copyright © 2022 Element. All rights reserved.
+//
+
+import Foundation
+import UIKit
+
+/// UIKitBackgroundTask is a concrete implementation of BackgroundTaskProtocol using UIApplication background task.
+class UIKitBackgroundTask: BackgroundTaskProtocol {
+    let name: String
+    var isRunning: Bool {
+        identifier != .invalid
+    }
+    let isReusable: Bool
+    let expirationHandler: BackgroundTaskExpirationHandler?
+    var elapsedTime: TimeInterval {
+        return Date().timeIntervalSince(startDate) * 1000
+    }
+
+    private let application: ApplicationProtocol
+    private var identifier: UIBackgroundTaskIdentifier = .invalid
+    private var useCounter: Int = 0
+    private let startDate: Date = Date()
+
+    /// Initializes and starts a new background task
+    /// - Parameters:
+    ///   - name: name
+    ///   - isReusable: flag indicating the task is reusable
+    ///   - application: application instance
+    ///   - expirationHandler: expiration handler
+    init?(name: String,
+          isReusable: Bool,
+          application: ApplicationProtocol,
+          expirationHandler: BackgroundTaskExpirationHandler?) {
+        self.name = name
+        self.isReusable = isReusable
+        self.application = application
+        self.expirationHandler = expirationHandler
+
+        // attempt to start
+        identifier = application.beginBackgroundTask(withName: name) { [weak self] in
+            guard let self = self else { return }
+            self.expirationHandler?(self)
+        }
+
+        if identifier == .invalid {
+            MXLog.debug("[UIKitBackgroundTask] Do not start background task: \(name), as OS declined")
+            //  call expiration handler immediately
+            expirationHandler?(self)
+            return nil
+        }
+
+        if isReusable {
+            //  creation itself is a use
+            reuse()
+        }
+
+        MXLog.debug("[UIKitBackgroundTask] Start background task #\(identifier.rawValue) - \(name)")
+    }
+
+    func reuse() {
+        guard isReusable else {
+            return
+        }
+        useCounter += 1
+    }
+
+    func stop() {
+        if isReusable {
+            useCounter -= 1
+            if useCounter <= 0 {
+                endTask()
+            }
+        } else {
+            endTask()
+        }
+    }
+
+    private func endTask() {
+        if identifier != .invalid {
+            MXLog.debug("[UIKitBackgroundTask] End background task #\(identifier.rawValue) - \(name) after \(readableElapsedTime)")
+
+            application.endBackgroundTask(identifier)
+            identifier = .invalid
+        }
+    }
+
+    private var readableElapsedTime: String {
+        String(format: "%.3fms", elapsedTime)
+    }
+}

ElementX/Sources/Services/Background/UIKitBackgroundTaskService.swift

@@ -0,0 +1,123 @@
+//
+//  UIKitBackgroundTaskService.swift
+//  ElementX
+//
+//  Created by Ismail on 28.06.2022.
+//  Copyright © 2022 Element. All rights reserved.
+//
+
+import Foundation
+import UIKit
+
+/// /// UIKitBackgroundTaskService is a concrete implementation of BackgroundTaskServiceProtocol using a given `ApplicationProtocol`  instance.
+class UIKitBackgroundTaskService: BackgroundTaskServiceProtocol {
+
+    private let application: ApplicationProtocol?
+    private var reusableTasks: WeakDictionary<String, UIKitBackgroundTask> = WeakDictionary()
+
+    /// Initializer
+    /// - Parameter application: application instance to use. Defaults to `UIApplication.extensionSafeShared`.
+    init(withApplication application: ApplicationProtocol? = UIApplication.extensionSafeShared) {
+        self.application = application
+    }
+
+    func startBackgroundTask(withName name: String,
+                             isReusable: Bool,
+                             expirationHandler: (() -> Void)?) -> BackgroundTaskProtocol? {
+        guard let application = application else {
+            MXLog.debug("[UIKitBackgroundTaskService] Do not start background task: \(name). Application is nil")
+            return nil
+        }
+
+        if avoidStartingNewTasks(for: application) {
+            MXLog.debug("[UIKitBackgroundTaskService] Do not start background task: \(name), as not enough time exists")
+            //  call expiration handler immediately
+            expirationHandler?()
+            return nil
+        }
+        var created: Bool = false
+        var result: BackgroundTaskProtocol?
+
+        if isReusable {
+            if let oldTask = reusableTasks[name], oldTask.isRunning {
+                oldTask.reuse()
+                result = oldTask
+            } else {
+                if let newTask = UIKitBackgroundTask(name: name,
+                                                     isReusable: isReusable,
+                                                     application: application,
+                                                     expirationHandler: { [weak self] task in
+                    guard let self = self else { return }
+                    self.reusableTasks[task.name] = nil
+                    expirationHandler?()
+                }) {
+                    created = true
+                    reusableTasks[name] = newTask
+                    result = newTask
+                }
+            }
+        } else {
+            if let newTask = UIKitBackgroundTask(name: name,
+                                                 isReusable: isReusable,
+                                                 application: application,
+                                                 expirationHandler: { _ in
+                expirationHandler?()
+            }) {
+                result = newTask
+                created = true
+            }
+        }
+
+        let appState = application.applicationState
+        let remainingTime = readableBackgroundTimeRemaining(application.backgroundTimeRemaining)
+
+        MXLog.debug("[UIKitBackgroundTaskService] Background task \(name) \(created ? "started" : "reused") with app state: \(appState) and estimated background time remaining: \(remainingTime)")
+
+        return result
+    }
+
+    private func readableBackgroundTimeRemaining(_ backgroundTimeRemaining: TimeInterval) -> String {
+        if backgroundTimeRemaining == .greatestFiniteMagnitude {
+            return "undetermined"
+        } else {
+            return String(format: "%.0f seconds", backgroundTimeRemaining)
+        }
+    }
+
+    private func avoidStartingNewTasks(for application: ApplicationProtocol) -> Bool {
+        if application.applicationState == .background
+            && application.backgroundTimeRemaining < .backgroundTimeRemainingThresholdToStartTasks {
+            return true
+        }
+        return false
+    }
+
+}
+
+private extension TimeInterval {
+    static let backgroundTimeRemainingThresholdToStartTasks: TimeInterval = 5
+}
+
+private extension UIApplication {
+    /// Application instance extension-safe. Will be `nil` on app extensions.
+    static var extensionSafeShared: UIApplication? {
+        let selector = NSSelectorFromString("sharedApplication")
+        guard Self.responds(to: selector) else { return nil }
+        return Self.perform(selector).takeUnretainedValue() as? UIApplication
+    }
+}
+
+extension UIApplication.State: CustomStringConvertible {
+    public var description: String {
+        switch self {
+        case .active:
+            return "active"
+        case .inactive:
+            return "inactive"
+        case .background:
+            return "background"
+        @unknown default:
+            return "unknown"
+        }
+    }
+}