BGTaskScheduler: Is it possible to schedule a background task inside a background task?

Question

Let's say an app has a background task to execute after 1 hour, but when it executes, it discovers that the user has no internet connection, so it cannot do its job. Is it possible to schedule another background task inside the background task to execute after another hour?

Answer 1

Yes, you can schedule the next task when processing the current task.

The code example in Using Background Tasks to Update Your App does precisely that, scheduling the next task (scheduleAppRefresh) as the first step in handling an app refresh:

func handleAppRefresh(task: BGAppRefreshTask) {
    // Schedule a new refresh task.
    scheduleAppRefresh()

    // Create an operation that performs the main part of the background task.
    let operation = RefreshAppContentsOperation()
   
    // Provide the background task with an expiration handler that cancels the operation.
    task.expirationHandler = {
        operation.cancel()
    }

    // Inform the system that the background task is complete
    // when the operation completes.
    operation.completionBlock = {
        task.setTaskCompleted(success: !operation.isCancelled)
    }

    // Start the operation.
    operationQueue.addOperation(operation)
}

Also see Refreshing and Maintaining Your App Using Background Tasks sample project.

---

For what it is worth, the above custom Operation subclass example (the RefreshAppContentsOperation object) might be a source of confusion for contemporary readers. The challenge is that when Apple wrote that example, a custom, asynchronous, Operation subclass was the state of the art for nice, encapsulated, cancelable, asynchronous units of work. But there now are better, more modern alternatives. E.g., we might now use the async-await of Swift concurrency:

func handleAppRefresh(task: BGAppRefreshTask) {
    // Schedule a new refresh task.
    scheduleAppRefresh()

    // Start refresh of the app data
    let updateTask = Task {
        do {
            try await self.refreshApp()
            task.setTaskCompleted(success: true)
        } catch {
            task.setTaskCompleted(success: false)
        }
    }

    // Provide the background task with an expiration handler that cancels the operation.
    task.expirationHandler = {
        updateTask.cancel()
    }
}

func refreshApp() async throws {
    // update the app with Swift concurrency, e.g., 
    
    let (data, response) = try await URLSession.shared.data(from: url)

    …

    // update model and presumably save it in local, persistent storage
}

But our apps may use wildly different mechanisms and API to fetch data updates, so it is best not to get lost in the details here. The key observations are that when we handle an app refresh, we:

• schedule the next refresh;
• initiate the asynchronous refresh of our app’s data;
• when our request finishes, mark the BGAppRefreshTask as complete; and
• if our request cannot finish in time, let the expirationHandler of our BGAppRefreshTask cancel our app refresh request.