TaskTrigger

Attach async tasks to SwiftUI views using a trigger mechanism. See this for examples.

Table Of Contents

• Usage
• Documentation
• Overview
• The Problem
• The Solution
• Contribution

Usage

dependencies: [
    .package(url: "https://github.com/lukepistrol/TaskTrigger.git", from: "0.1.0"),
],

Make sure to import TaskTrigger in any location you'd want to use it.

Documentation

The documentation is available here.

You can also have a look at the sample project

Overview

When using Swift's structured concurrency in SwiftUI it is good practice to tie the tasks to the relevant view's lifetime in order to support task cancellation should the view be dismissed.

The Problem

This can already be achieved by using the task(id:priority:_:) view modifier. However this requires additional housekeeping for the id.

In a primitive example where we just want to trigger some task we might use a Bool for the id:

@State var triggerTask: Bool = false

var body: some View {
    Button("Do Something") {
        triggerTask = true
    }
    .task(id: triggerTask) {
        guard triggerTask else { return }
        await someAsyncOperation()
        triggerTask = false
    }
}

This makes even more sense in a more complicated example where we have a list of views where we would like to do something based on some identifier:

@State var triggerTaskId: Int?

var body: some View {
    List(0..<10) { index in
        Button("Item \(index)") {
            triggerTaskId = index
        }
    }
    .task(id: triggerTaskId) {
        guard let triggerTaskId else { return }
        await someAsyncOperation(for: triggerTaskId)
        triggerTaskId = nil
    }
}

This approach, while it really works well, comes with a lot of overhead directly in our view. Also we have to call the state value directly from within our task which might be cumbersome when we hold the state in a view model.

The Solution

To make things simpler on the caller's side let's wrap all of this functionality inside a simple type TaskTrigger.

@State var trigger = TaskTrigger<Int>()

var body: some View {
    List(0..<10) { index in
        Button("Item \(index)") {
            trigger.trigger(value: index)
        }
    }
    .task($trigger) { index in
        await someAsyncOperation(for: index)
    }
}

1. We declare a new state variable trigger and initialize the TaskTrigger of type Int.
2. In our button we call the trigger(value:id:) method on our trigger and pass in our value.
3. We attach a new variant of the task view modifier to our view and bind it to our trigger.
4. The body will only execute when the trigger was triggered. The value we passed into the trigger(value:id:) method earlier gets passed into the closure as an argument.
5. All cancellation related handling, sanity checking, as well as resetting the state is handled automatically behind the scenes.

For triggers that don't need to attach a value, we can simply use PlainTaskTrigger (which is a typealias for TaskTrigger<Bool>):

@State var trigger = PlainTaskTrigger()

var body: some View {
    Button("Do Something") {
        trigger.trigger()
    }
    .task($trigger) {
        await someAsyncOperation()
    }
}

Contribution

If you have any ideas on how to take this further I'm happy to discuss things in an issue.