Mastering iOS App States: Foreground vs. Background Execution

import UIKit

@main
class AppDelegate: UIResponder, UIApplicationDelegate {

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Override point for customization after application launch.
        print("App launched.")
        return true
    }

    // MARK: UISceneSession Lifecycle

    func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
        // Called when a new scene session is being created.
        // Use this method to select a configuration to create the new scene with.
        return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
    }

    func application(_ application: UIApplication, didDiscardSceneSessions sceneSessions: Set<UISceneSession>) {
        // Called when the user discards a scene session.
        // If any sessions were discarded while the application was not running, this will be called shortly after application:didFinishLaunchingWithOptions.
        // Use this method to release any resources that were specific to the discarded scenes, as they will not return.
    }

    func applicationWillResignActive(_ application: UIApplication) {
        print("App will resign active (going to inactive).")
    }

    func applicationDidEnterBackground(_ application: UIApplication) {
        print("App entered background.")
        // You can request extra execution time here for short tasks.
    }

    func applicationWillEnterForeground(_ application: UIApplication) {
        print("App will enter foreground.")
    }

    func applicationDidBecomeActive(_ application: UIApplication) {
        print("App became active.")
        // Restart tasks that were paused (or not yet started) while the app was inactive.
    }

    func applicationWillTerminate(_ application: UIApplication) {
        print("App will terminate.")
        // Called when the application is about to terminate. Save data if appropriate.
    }
}

import SwiftUI

@main
struct MyApp: App {
    @Environment(\.scenePhase) private var scenePhase

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
        .onChange(of: scenePhase) { oldPhase, newPhase in
            switch newPhase {
            case .active:
                print("App is active.")
            case .inactive:
                print("App is inactive.")
            case .background:
                print("App is in background.")
                // Perform lightweight background tasks or save state
            @unknown default:
                print("Unknown scene phase.")
            }
        }
    }
}

import UIKit

class DataManager {
    static let shared = DataManager()
    private var backgroundTask: UIBackgroundTaskIdentifier = .invalid

    func saveImportantData() {
        print("Attempting to save important data in background...")

        // Request extra background execution time
        backgroundTask = UIApplication.shared.beginBackgroundTask(withName: "PersistData") {
            // This block is called if the system needs to reclaim its background time.
            print("Background task expired for saving data.")
            self.endBackgroundTask()
        }

        // Perform your long-running task here
        DispatchQueue.global().async {
            // Simulate a network request or heavy data processing
            Thread.sleep(forTimeInterval: 25) // Takes 25 seconds
            print("Data saved successfully in background!")
            self.endBackgroundTask()
        }
    }

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

// In AppDelegate's applicationDidEnterBackground:
// DataManager.shared.saveImportantData()

// In AppDelegate's didFinishLaunchingWithOptions:
application.setMinimumBackgroundFetchInterval(UIApplication.backgroundFetchIntervalMinimum)

// Implement this method to perform your fetch:
func application(_ application: UIApplication, performFetchWithCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
    print("Performing background fetch...")

    // Simulate fetching new data
    DispatchQueue.global().asyncAfter(deadline: .now() + 5) {
        let newDataAvailable = Bool.random() // Assume we fetched some data

        if newDataAvailable {
            print("New data fetched.")
            // Update UI/model here but don't perform heavy UI updates as app is in background
            completionHandler(.newData)
        } else {
            print("No new data.")
            completionHandler(.noData)
        }
    }
}

import BackgroundTasks

let refreshTaskIdentifier = "com.yourapp.apprefresh"
let processingTaskIdentifier = "com.yourapp.dataprocesing"

// In AppDelegate's didFinishLaunchingWithOptions:
BGTaskScheduler.shared.register(forTaskWithIdentifier: refreshTaskIdentifier, using: nil) { task in
    self.handleAppRefreshTask(task as! BGAppRefreshTask)
}
BGTaskScheduler.shared.register(forTaskWithIdentifier: processingTaskIdentifier, using: nil) { task in
    self.handleProcessingTask(task as! BGProcessingTask)
}

// Schedule a refresh task (e.g., when new data arrives or app goes to background)
func scheduleAppRefresh() {
    let request = BGAppRefreshTaskRequest(identifier: refreshTaskIdentifier)
    request.earliestBeginDate = Date(timeIntervalSinceNow: 15 * 60) // Not sooner than 15 minutes

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

// Schedule a processing task
func scheduleDataProcessing() {
    let request = BGProcessingTaskRequest(identifier: processingTaskIdentifier)
    request.requiresNetworkConnectivity = true // Only run if network is available
    request.requiresExternalPower = false // Can run without external power
    request.earliestBeginDate = Date(timeIntervalSinceNow: 30 * 60) // Not sooner than 30 minutes

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

// Handlers for the tasks
func handleAppRefreshTask(_ task: BGAppRefreshTask) {
    print("Handling app refresh task for identifier: \(task.identifier).")

    // Schedule a new refresh task for next time
    scheduleAppRefresh()

    // Create an asynchronous operation to perform the fetch
    let operation = BlockOperation {
        // Simulate fetching new content
        Thread.sleep(forTimeInterval: 10)
        print("Background app refresh completed!")
        task.setTaskCompleted(success: true)
    }

    task.expirationHandler = {
        // Clean up any resources and cancel active operations
        operation.cancel()
        print("App refresh task expired.")
    }

    let queue = OperationQueue()
    queue.addOperation(operation)
}

func handleProcessingTask(_ task: BGProcessingTask) {
    print("Handling processing task for identifier: \(task.identifier).")

    // Schedule a new processing task for next time
    scheduleDataProcessing()

    // Create an asynchronous operation for heavy processing
    let operation = BlockOperation {
        // Simulate heavy data computation or large upload
        Thread.sleep(forTimeInterval: 60) // Takes 60 seconds
        print("Background processing completed!")
        task.setTaskCompleted(success: true)
    }

    task.expirationHandler = {
        operation.cancel()
        print("Processing task expired.")
    }

    let queue = OperationQueue()
    queue.addOperation(operation)
}

// Example usage: In applicationDidEnterBackground
// scheduleAppRefresh()
// scheduleDataProcessing()