Mastering iOS Background Execution: Keep Your Apps Alive

import UIKit

class BackgroundTaskExample:
    private var backgroundTask: UIBackgroundTaskIdentifier = .invalid

    func performLongRunningOperation() {
        print("Starting long-running operation...")

        // Register a background task
        backgroundTask = UIApplication.shared.beginBackgroundTask(withName: "MyDataUploadTask") {
            // This block is called if the system needs to reclaim time
            self.endBackgroundTask()
            print("Background task expired before completion.")
        }

        // Simulate a network request or data processing
        DispatchQueue.global().asyncAfter(deadline: .now() + 20) { // Simulate 20 seconds of work
            // Ensure we are not trying to do UI updates on background thread
            DispatchQueue.main.async {
                print("Long-running operation completed!")
                self.endBackgroundTask()
            }
        }
    }

    private func endBackgroundTask() {
        if backgroundTask != .invalid {
            UIApplication.shared.endBackgroundTask(backgroundTask)
            backgroundTask = .invalid
            print("Background task ended.")
        }
    }
}

import UIKit

class AppDelegate: UIResponder, UIApplicationDelegate {

    var window: UIWindow?

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Override point for customization after application launch.
        
        // Set the minimum background fetch interval
        // Use .minimum to let the system determine the best interval
        UIApplication.shared.setMinimumBackgroundFetchInterval(UIApplication.backgroundFetchIntervalMinimum)
        return true
    }

    func application(_ application: UIApplication, performFetchWithCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
        print("Background Fetch initiated.")

        // Simulate a network request
        DispatchQueue.global().asyncAfter(deadline: .now() + 5) { // Simulate 5 seconds of fetching
            let newDataAvailable = Bool.random() // Simulate whether new data was found

            if newDataAvailable {
                print("New data fetched in background.")
                // Process and save your new data here
                completionHandler(.newData)
            } else {
                print("No new data fetched in background.")
                completionHandler(.noData)
            }
        }
    }

    // ... other AppDelegate methods
}

import UIKit

class BackgroundDownloadManager: NSObject, URLSessionDelegate, URLSessionDownloadDelegate {

    static let shared = BackgroundDownloadManager()
    private var backgroundSession: URLSession!
    private var completionHandlers = [String: () -> Void]()

    override init() {
        super.init()
        let config = URLSessionConfiguration.background(withIdentifier: "com.yourapp.backgrounddownload")
        config.isDiscretionary = true // Let the system decide when to transfer for optimal performance
        config.sessionSendsLaunchEvents = true // App will be relaunched if needed
        backgroundSession = URLSession(configuration: config, delegate: self, delegateQueue: nil)
    }

    func startDownload(from url: URL) {
        let downloadTask = backgroundSession.downloadTask(with: url)
        downloadTask.resume()
        print("Started background download for: \(url.lastPathComponent)")
    }

    // MARK: - URLSessionDownloadDelegate

    func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask, didFinishDownloadingTo location: URL) {
        print("Download finished to: \(location.lastPathComponent)")
        // Move the downloaded file from the temporary location to app's desired directory
        // Example: let destinationURL = getAppDocumentsDirectory().appendingPathComponent(downloadTask.originalRequest!.url!.lastPathComponent)
        // try? FileManager.default.moveItem(at: location, to: destinationURL)
    }

    // MARK: - URLSessionDelegate

    func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
        if let error = error {
            print("Download task completed with error: \(error.localizedDescription)")
        } else {
            print("Download task completed successfully.")
        }
    }

    func urlSessionDidFinishEvents(forBackgroundURLSession session: URLSession) {
        print("All background session events have been delivered.")
        // Call the stored completion handler for the AppDelegate
        DispatchQueue.main.async {
            self.completionHandlers[session.configuration.identifier ?? ""]?()
            self.completionHandlers.removeValue(forKey: session.configuration.identifier ?? "")
        }
    }

    // Method to be called from AppDelegate's handleEventsForBackgroundURLSession
    func addCompletionHandler(identifier: String, handler: @escaping () -> Void) {
        completionHandlers[identifier] = handler
    }
}

// In your AppDelegate.swift
// func application(_ application: UIApplication, handleEventsForBackgroundURLSession identifier: String, completionHandler: @escaping () -> Void) {
//     BackgroundDownloadManager.shared.addCompletionHandler(identifier: identifier, handler: completionHandler)
// }

import BackgroundTasks
import UIKit

class BGTaskSchedulerExample {

    static let appRefreshTaskIdentifier = "com.yourapp.apprefresh"
    static let dataProcessingTaskIdentifier = "com.yourapp.dataprocessing"

    func registerBackgroundTasks() {
        // Register background app refresh task
        BGTaskScheduler.shared.register(forTaskWithIdentifier: BGTaskSchedulerExample.appRefreshTaskIdentifier, using: nil) { task in
            // Perform your app refresh directly here
            self.handleAppRefreshTask(task as! BGAppRefreshTask)
        }

        // Register background processing task
        BGTaskScheduler.shared.register(forTaskWithIdentifier: BGTaskSchedulerExample.dataProcessingTaskIdentifier, using: nil) { task in
            // Perform your data processing directly here
            self.handleProcessingTask(task as! BGProcessingTask)
        }
    }

    func scheduleAppRefresh() {
        let request = BGAppRefreshTaskRequest(identifier: BGTaskSchedulerExample.appRefreshTaskIdentifier)
        // Optional: define when the earliest the task can be run
        request.earliestBeginDate = Date(timeIntervalSinceNow: 15 * 60) // Not sooner than 15 minutes from now

        do {
            try BGTaskScheduler.shared.submit(request)
            print("App refresh task scheduled.")
        } catch {
            print("Could not schedule app refresh task: \(error)")
        }
    }

    func scheduleProcessingTask() {
        let request = BGProcessingTaskRequest(identifier: BGTaskSchedulerExample.dataProcessingTaskIdentifier)
        request.requiresNetworkConnectivity = true // Only run when network is available
        request.requiresExternalPower = true       // Only run when device is charging
        request.earliestBeginDate = Date(timeIntervalSinceNow: 30 * 60) // Not sooner than 30 minutes

        do {
            try BGTaskScheduler.shared.submit(request)
            print("Processing task scheduled.")
        } catch {
            print("Could not schedule processing task: \(error)")
        }
    }

    private func handleAppRefreshTask(_ task: BGAppRefreshTask) {
        print("Handling app refresh task...")

        // Schedule a new refresh task for the future
        scheduleAppRefresh()

        // Simulate fetching new data
        let operationQueue = OperationQueue()
        operationQueue.maxConcurrentOperationCount = 1
        operationQueue.addOperation {
            print("Performing actual app refresh...")
            Thread.sleep(forTimeInterval: 5)
            print("App refresh done.")

            // Mark the task as complete
            task.setTaskCompleted(success: true)
        }

        // Provide a handler to be called if the system needs to preempt the task
        task.expirationHandler = {
            operationQueue.cancelAllOperations()
            print("App refresh task expired.")
            task.setTaskCompleted(success: false)
        }
    }

    private func handleProcessingTask(_ task: BGProcessingTask) {
        print("Handling processing task...")

        // Schedule a new processing task for the future
        scheduleProcessingTask()

        // Simulate long-running processing
        let operationQueue = OperationQueue()
        operationQueue.maxConcurrentOperationCount = 1
        operationQueue.addOperation {
            print("Performing actual processing...")
            Thread.sleep(forTimeInterval: 20) // Simulate a longer task
            print("Processing done.")

            // Mark the task as complete
            task.setTaskCompleted(success: true)
        }

        // Provide a handler to be called if the system needs to preempt the task
        task.expirationHandler = {
            operationQueue.cancelAllOperations()
            print("Processing task expired.")
            task.setTaskCompleted(success: false)
        }
    }
}

/*
// In your AppDelegate `didFinishLaunchingWithOptions`:
let bgTaskScheduler = BGTaskSchedulerExample()
bgTaskScheduler.registerBackgroundTasks()

// In your AppDelegate `applicationDidEnterBackground` (or equivalent for SceneDelegate):
bgTaskScheduler.scheduleAppRefresh()
bgTaskScheduler.scheduleProcessingTask()
*/