task on Software Development Notes

Can ChatGPT create an iOS app in SwiftUI - part 2

Eric Callanan — Sunday, 02 Apr 2023

The initial Task Manager app created with code from ChatGPT did not quite work correctly. In this article, I work with ChatGPT to resolve the issues and then add the ability to persist the tasks when the app is closed.

It is worth noting that this experiment was started with ChatGPT version 3.5, but by the time part-1 was published, a newer version was released. ChatGPT version 4.0 (GPT-4) was released on March 14th and is publicly available in a limited form to ChatGPT Plus subscribers. I suspect this may be the nature of working with ChatGPT with newer versions coming at an ever increasing rate. I have started playing around with GPT-4, but I'll leave that for another day.

Related articles on ChatGPT and SwiftUI:

Can ChatGPT create an iOS app in SwiftUI - part 1

Can ChatGPT create an iOS app in SwiftUI - part 2

Create a circular slider in SwiftUI with ChatGPT

Issues with editing tasks in the Task Manager App

In part 1 ChatGPT had created the bones of a Task Manager app, albeit with one small defect, in that the app did not save the edits to the tasks. The Edit button appeared to allow the user to edit any and all of the tasks, but when the done button was selected, the edits were not displayed and the tasks seemed to revert to their original content.

Digging into the code that was created shows a couple of errors:

The code in EditableTaskView creates a local copy of the dueDate and does not set the selected value back to the Task dueDate.

Changes made in EditableTaskView for Title and Status are saved to the TaskViewModel but these are not shown in the main list by TaskView.

There is a relatively easy fix for both of these issues using the relatively new element binding syntax introduced in 2021 with Xcode 13.

It is not clear how to get ChatGPT to create this code. Neither is it clear how I could progress with ChatGPT with further enhancements if I manually make these code changes. How should I inform ChatGPT that the code has been modified?

The following are a number of interactions with ChatGPT to try and get the app working. One great advantage with ChatGPT is that you can ask it to Regenerate a response over and over again.

First prompt to fix the problem

done button in ContentView does not display the edits to the tasks

Response from chatGPT

It's likely that the updateTask method in the TaskListViewModel is not properly updating the task with the edited values.

When the user taps the "Done" button in the EditTaskView, the updateTask method is called with the edited Task instance. This method should then find the corresponding task in the tasks array and update its properties with the new values...

The update code suggested by ChatGPT includes use of TaskListViewModel, but there is no TaskListViewModel in the code. The code seems to be referring to a variation of TaskViewModel, but would require further refactoring to get it to work.

Second prompt to fix the problem

EditableTaskView does not save task changes back to the ViewModel when done
button in ContentView is selected

Response from chatGPT

To make the EditableTaskView save task changes back to the ViewModel when the "Done" button in the ContentView is selected, you can add a completion handler to the EditableTaskView and call it when the user taps the "Done" button. Here's an updated version of the EditableTaskView:...

This solution of the code from ChatGPT also refers to taskListViewModel in the ContentView, which does not exist in the App code.

After some debugging into the code, I realise that my previous prompt is incorrect. The edits for title and status are saved to the ViewModel, but these changes are not displayed by the TaskView. I update the prompt to ChatGPT to the following.

Third prompt to fix the problem

EditableTaskView saves the task changes except for the date to the ViewModel when
done button in ContentView is selected. However the changes in the ViewModel are
not shown in the TaskView views

Response from chatGPT

If the changes to the Task instances in the TaskViewModel are not reflected in the TaskView views after editing a task, it's likely because the TaskView views are not observing the changes in the TaskViewModel. Here's how you can fix this issue:

Step 1: Add an id property to the TaskView struct.

TaskView.swift

 1struct TaskView: View {
 2    let task: Task
 3    let id: UUID
 4    
 5    var body: some View {
 6        VStack(alignment: .leading) {
 7            Text(task.title)
 8            if let dueDate = task.dueDate {
 9                Text("Due date: \(dueDate, formatter: ContentView.taskDateFormat)")
10                    .font(.caption)
11            }
12            Text("Status: \(task.status.rawValue)")
13        }
14        .foregroundColor(task.completed ? .gray : .primary)
15        .opacity(task.completed ? 0.5 : 1)
16        .id(id) // Add id
17    }
18}

Step 2: Modify the ForEach loop in the ContentView to pass the id of each task to the TaskView.

ContentView.swift

 1struct ContentView: View {
 2    @ObservedObject var viewModel = TaskViewModel()
 3    
 4    static let taskDateFormat: DateFormatter = {
 5        let formatter = DateFormatter()
 6        formatter.dateStyle = .medium
 7        return formatter
 8    }()
 9    
10    var body: some View {
11        NavigationView {
12            List {
13                ForEach(viewModel.tasks) { task in
14                    if viewModel.isEditing {
15                        EditableTaskView(task: $viewModel.tasks[viewModel.tasks.firstIndex(of: task)!])
16                    } else {
17                        TaskView(task: task, id: task.id) // Pass id to TaskView
18                    }
19                }
20                .onDelete { indexSet in
21                    self.viewModel.tasks.remove(atOffsets: indexSet)
22                }
23            }
24            .navigationTitle("Tasks")
25            .navigationBarItems(
26                trailing: HStack {
27                    if viewModel.isEditing {
28                        Button("Done") {
29                            self.viewModel.isEditing.toggle()
30                        }
31                    } else {
32                        Button(action: {
33                            self.viewModel.tasks.append(Task(title: "New Task", dueDate: Date(), status: .notStarted))
34                        }) {
35                            Image(systemName: "plus")
36                        }
37                        Button("Edit") {
38                            self.viewModel.isEditing.toggle()
39                        }
40                    }
41                }
42            )
43        }
44    }
45}

Step 3: Make sure that the TaskView is observing the Task instance using the @ObservedObject property wrapper.

TaskView.swift

 1struct TaskView: View {
 2    @ObservedObject var task: Task // Use @ObservedObject property wrapper instead of let
 3    let id: UUID
 4    
 5    var body: some View {
 6        VStack(alignment: .leading) {
 7            Text(task.title)
 8            if let dueDate = task.dueDate {
 9                Text("Due date: \(dueDate, formatter: ContentView.taskDateFormat)")
10                    .font(.caption)
11            }
12            Text("Status: \(task.status.rawValue)")
13        }
14        .foregroundColor(task.completed ? .gray : .primary)
15        .opacity(task.completed ? 0.5 : 1)
16        .id(id)
17    }
18}

With these changes, the TaskView instances will observe changes to their associated Task instances, so any updates made to the Task instances in the TaskViewModel will be reflected in the UI.

Overall, this is not a good idea. There are two versions of TaskView generated and Task was defined as a Struct and not an ObservableObject class. This would require more code changes to get the code to compile and even then, it may still not work. Let's try and regenerate the response to see what other solutions ChatGPT can provide.

This code does not compile.

Compile error with using Task as ObserverObject - code generated by ChatGPT

Same prompt to fix the problem - second response

EditableTaskView saves the task changes except for the date to the ViewModel when
done button in ContentView is selected. However the changes in the ViewModel are
not shown in the TaskView views

Response from chatGPT

If I understand your question correctly, you're saying that the changes made to a Task in the EditableTaskView are not reflected in the TaskView instances that display the same task, even though the changes are correctly saved to the TaskViewModel. If that's the case, here's how you can fix it:

Step 1: Modify the TaskView to use a Binding for the Task instance, instead of a constant value.

TaskView.swift

 1struct TaskView: View {
 2    @Binding var task: Task // change to a binding
 3    
 4    var body: some View {
 5        VStack(alignment: .leading) {
 6            Text(task.title)
 7            if let dueDate = task.dueDate {
 8                Text("Due date: \(dueDate, formatter: ContentView.taskDateFormat)")
 9                    .font(.caption)
10            }
11            Text("Status: \(task.status.rawValue)")
12        }
13        .foregroundColor(task.completed ? .gray : .primary)
14        .opacity(task.completed ? 0.5 : 1)
15    }
16}

Step 2: Update the ForEach loop in ContentView to use a Binding for each Task.

ContentView.swift

 1    . . .
 2
 3    List {
 4        ForEach($viewModel.tasks) { $task in // use a binding
 5            if viewModel.isEditing {
 6                EditableTaskView(task: $task)
 7            } else {
 8                TaskView(task: $task) // use a binding
 9            }
10        }
11        .onDelete { indexSet in
12            self.viewModel.tasks.remove(atOffsets: indexSet)
13        }
14    }
15
16    . . .

Step 3: In EditableTaskView, use the Binding passed in as the task parameter directly when modifying the Task instance.

EditableTaskView.swift

 1struct EditableTaskView: View {
 2    @Binding var task: Task
 3    
 4    var body: some View {
 5        VStack(alignment: .leading) {
 6            TextField("Title", text: $task.title)
 7            if let dueDate = task.dueDate {
 8                DatePicker("Due date", selection: Binding<Date>(
 9                    get: { dueDate },
10                    set: { newValue in self.task.dueDate = newValue } // use the binding directly
11                ), displayedComponents: .date)
12            }
13            Picker("Task Status", selection: $task.status) {
14                ForEach(TaskStatus.allCases, id: \.self) { status in
15                    Text(status.rawValue).tag(status)
16                }
17            }
18            .pickerStyle(SegmentedPickerStyle())
19        }
20        .foregroundColor(task.completed ? .gray : .primary)
21        .opacity(task.completed ? 0.5 : 1)
22    }
23}

With these changes, the TaskView instances will use Bindings to the Task instances in the TaskViewModel, so any changes made to a Task in the EditableTaskView will be reflected in the corresponding TaskView instances.

I have to admit - I was stunned. These are exactly the changes I had made manually to get the app to work.

Edits made to Tasks are shown in task view - code generated by ChatGPT

Persist the Tasks for the app - 1

The tasks can be edited and new tasks can be added, but the app restores to the default three tasks whenever it is restarted. The tasks need to be persisted to make the app useful.

Prompt to persist the task list

Persist the list of tasks when the iOS app is closed using userdefaults

Response from chatGPT

Sure! Here's an example of how you could modify the TaskViewModel to persist the list of tasks in UserDefaults when the app is closed, and to load the saved tasks when the app is launched again.

Step 1: Add a UserDefaults property to TaskViewModel to hold the shared UserDefaults instance.

TaskViewModel.swift

1class TaskViewModel: ObservableObject {
2    private let userDefaults = UserDefaults.standard
3    // ...
4}

Step 2: Modify the init method of TaskViewModel to load the saved tasks from UserDefaults, if available.

TaskViewModel.swift

 1class TaskViewModel: ObservableObject {
 2    // ...
 3    
 4    init() {
 5        if let savedTasksData = userDefaults.data(forKey: "tasks"),
 6           let savedTasks = try? JSONDecoder().decode([Task].self, from: savedTasksData) {
 7            self.tasks = savedTasks
 8        }
 9    }
10    
11    // ...
12}

In this modification, we use the data(forKey:) method of UserDefaults to retrieve the saved data for the "tasks" key, and then use JSONDecoder to decode the data as an array of Task instances. If the decoding succeeds, we set the tasks property to the decoded value.

Step 3: Modify the TaskViewModel method that saves the list of tasks to UserDefaults to be called whenever the list changes, as well as when the app is closed.

TaskViewModel.swift

 1class TaskViewModel: ObservableObject {
 2    // ...
 3    
 4    func saveTasks() {
 5        if let encodedTasks = try? JSONEncoder().encode(tasks) {
 6            userDefaults.set(encodedTasks, forKey: "tasks")
 7        }
 8    }
 9    
10    // ...
11}

In this modification, we encode the current list of tasks using JSONEncoder, and then save the encoded data to UserDefaults using the "tasks" key.

Step 4: Add a ScenePhase property to ContentView to detect when the app is closing, and call the TaskViewModel method that saves the list of tasks.

TasksAppWithChatGptApp.swift

 1@main
 2struct TaskManagerApp: App {
 3    @Environment(\.scenePhase) private var scenePhase
 4    
 5    var body: some Scene {
 6        WindowGroup {
 7            ContentView()
 8                .environmentObject(TaskViewModel())
 9        }
10        .onChange(of: scenePhase) { newScenePhase in
11            if newScenePhase == .inactive || newScenePhase == .background {
12                let taskViewModel = TaskViewModel()
13                taskViewModel.saveTasks()
14            }
15        }
16    }
17}

In this modification, we use the onChange(of:) modifier to detect changes in the ScenePhase environment value, and call the TaskViewModel method that saves the list of tasks when the app is closing (i.e. when scenePhase is set to .inactive or .background).

With these modifications, the list of tasks will be saved to UserDefaults whenever the app is closed, and loaded from UserDefaults when the app is launched again.

This code does not compile with errors on encoding and decoding tasks.

Errors with json encoding/decoding tasks - code generated by ChatGPT

Prompt to fix the encoding errors

Two errorsClass 'JSONDecoder' requires that 'Task' conform to 'Decodable'

Here, I mis-typed the prompt, but ChatGPT gave the correct response anyway.

Response from chatGPT

The error message indicates that the Task struct does not conform to the Decodable protocol, which is required in order to be able to decode it from JSON using JSONDecoder.

To fix this error, you need to make sure that Task conforms to Decodable. Here's an example of how you could modify the Task struct to conform to Decodable:

Task.swift

 1struct Task: Identifiable, Equatable, Codable {
 2    var id = UUID()
 3    var title: String
 4    var dueDate: Date?
 5    var status: TaskStatus
 6    var completed = false
 7    
 8    enum CodingKeys: String, CodingKey {
 9        case id, title, dueDate, status, completed
10    }
11    
12    init(id: UUID = UUID(), title: String, dueDate: Date?, status: TaskStatus, completed: Bool = false) {
13        self.id = id
14        self.title = title
15        self.dueDate = dueDate
16        self.status = status
17        self.completed = completed
18    }
19    
20    init(from decoder: Decoder) throws {
21        let container = try decoder.container(keyedBy: CodingKeys.self)
22        id = try container.decode(UUID.self, forKey: .id)
23        title = try container.decode(String.self, forKey: .title)
24        dueDate = try container.decodeIfPresent(Date.self, forKey: .dueDate)
25        status = try container.decode(TaskStatus.self, forKey: .status)
26        completed = try container.decode(Bool.self, forKey: .completed)
27    }
28    
29    func encode(to encoder: Encoder) throws {
30        var container = encoder.container(keyedBy: CodingKeys.self)
31        try container.encode(id, forKey: .id)
32        try container.encode(title, forKey: .title)
33        try container.encodeIfPresent(dueDate, forKey: .dueDate)
34        try container.encode(status, forKey: .status)
35        try container.encode(completed, forKey: .completed)
36    }
37}

In this modified version of the Task struct, we've added conformance to Codable, which is a protocol that combines Encodable and Decodable conformance. We've also implemented the init(from:) and encode(to:) methods required by Decodable and Encodable, respectively.

With these modifications, you should be able to decode Task instances from JSON using JSONDecoder.

This appears to fix the Codable issues with Tasks, but reveals an initialisation error with TaskViewModel.

TaskViewModel initialisation Errors - code generated by ChatGPT

Prompt to fix the initialisation error

error in TaskViewModel - Return from initializer without initializing all stored
properties

Response from chatGPT

This error message indicates that there is a code path in the init method of TaskViewModel that doesn't initialize all the stored properties of the class.

To fix this error, you need to make sure that all stored properties of TaskViewModel are initialized in the init method. Here's an example of how you could modify the init method to ensure that all stored properties are initialized:

TaskViewModel.swift

 1class TaskViewModel: ObservableObject {
 2    private let userDefaults: UserDefaults
 3    @Published var tasks: [Task]
 4    @Published var isEditing = false
 5    
 6    init() {
 7        self.userDefaults = UserDefaults.standard
 8        self.tasks = []
 9        
10        if let savedTasksData = userDefaults.data(forKey: "tasks"),
11           let savedTasks = try? JSONDecoder().decode([Task].self, from: savedTasksData) {
12            self.tasks = savedTasks
13        }
14    }
15    
16    func saveTasks() {
17        if let encodedTasks = try? JSONEncoder().encode(tasks) {
18            userDefaults.set(encodedTasks, forKey: "tasks")
19        }
20    }
21    
22    // ...
23}

In this modified version of TaskViewModel, we've added explicit initialization for both the userDefaults and tasks properties in the init method. We also removed the @State property wrapper from isEditing, since it's not used in a View.

With these modifications, the init method should initialize all stored properties of TaskViewModel, and the "Return from initializer without initializing all stored properties" error should be resolved.

Compiling the app now reveals 4 errors. Two of these errors are in TaskView_Previews, which ChatGPT does not know about - so I could comment out the preview or just fix them. The errors in Task should have really been addressed when making Task codable. The property for Status is an enum and this should also have been marked as codable.

So I pass this error back to ChatGPT.

Error because TaskStatus enum is not codable - code generated by ChatGPT

Prompt to fix TaskStatus codable error

error in Task - Instance method 'decode(_:forKey:)' requires that 'TaskStatus'
conform to 'Decodable'

Response from chatGPT

The error message indicates that the TaskStatus enum does not conform to the Decodable protocol, which is required in order to be able to decode it from JSON using JSONDecoder.

To fix this error, you need to make sure that TaskStatus conforms to Decodable. Here's an example of how you could modify the TaskStatus enum to conform to Decodable:

Task.swift

1enum TaskStatus: String, Codable {
2    case notStarted = "Not Started"
3    case inProgress = "In Progress"
4    case complete = "Complete"
5}

In this modified version of TaskStatus, we've added conformance to Codable, which is a protocol that combines Encodable and Decodable conformance.

With this modification, you should be able to decode Task instances from JSON using JSONDecoder.

This code is technically wrong as it removes CaseIterable, which is used to iterate through the Status options. So I just add Codable.

1enum TaskStatus: String, CaseIterable, Codable {
2    case notStarted = "Not started"
3    case inProgress = "In progress"
4    case complete = "Complete"
5}

The code now compiles and runs. Tasks can be added and edited.

However, all the tasks disappear when the user switches App and the tasks are not persisted.

All Tasks disappear when switching apps - code generated by ChatGPT

Persist the Tasks for the app - 2

A review of the code shows that there is a new instance of TaskViewModel is created in TaskManagerApp in the onChange(of: scenePhase). A new instance TaskViewModel loads the Tasks fron UserDefaults or uses an empty list. So the list id always empty.

Prompt to address the issue in TaskManagerApp

problem in TaskManagerApp - a new TaskViewModel is created in .onChange(of:
scenePhase)

Response from chatGPT

You are correct. In the onChange(of:scenePhase:) modifier in the TaskManagerApp struct, a new instance of TaskViewModel is created instead of using the existing instance.

To fix this problem, you can modify TaskManagerApp to pass the existing instance of TaskViewModel to the ContentView and use that instance throughout the app. Here's an example of how you can modify TaskManagerApp to achieve this:

View

 1@main
 2struct TaskManagerApp: App {
 3    @Environment(\.scenePhase) private var scenePhase
 4    
 5    let taskViewModel = TaskViewModel()
 6    
 7    var body: some Scene {
 8        WindowGroup {
 9            ContentView()
10                .environmentObject(taskViewModel)
11        }
12        .onChange(of: scenePhase) { newScenePhase in
13            if newScenePhase == .inactive || newScenePhase == .background {
14                taskViewModel.saveTasks()
15            }
16        }
17    }
18}

In this modified version of TaskManagerApp, we create a single instance of TaskViewModel and pass it to ContentView using the environmentObject(_:) method. This ensures that the same instance of TaskViewModel is used throughout the app, including in the onChange(of:scenePhase:) modifier.

With this modification, you should be able to use the existing instance of TaskViewModel to save and load tasks from UserDefaults, without creating a new instance of TaskViewModel each time the app enters the background.

This does not fix the problem as it looks like ContentView is still creating a new instance of TaskViewModel rather than using the environmentObject one. So this is what we feedback to ChatGPT.

All Tasks disappear when switching apps - code generated by ChatGPT

Prompt to fix ContentView to use environmentObject

it looks like ContentView is still creating a new instance of TaskViewModel
rather than using the environmentObject one

Response from chatGPT

You're right. In the ContentView struct, a new instance of TaskViewModel is created using the TaskViewModel() initializer, which creates a new instance of UserDefaults. This will prevent ContentView from accessing the same data as the rest of the app, which is stored in the shared instance of TaskViewModel.

To fix this, you should modify the ContentView struct to use the @EnvironmentObject property wrapper to access the existing instance of TaskViewModel that was passed down from TaskManagerApp. Here's an example of how you can modify the ContentView struct:

ContentView.swift

1struct ContentView: View {
2    @EnvironmentObject var viewModel: TaskViewModel
3    
4    // ...
5}

In this modified version of ContentView, we've added the @EnvironmentObject property wrapper to viewModel, which tells SwiftUI to look up the existing instance of TaskViewModel that was passed down from TaskManagerApp. This ensures that ContentView uses the same instance of TaskViewModel as the rest of the app, rather than creating a new instance with its own UserDefaults.

With this modification, ContentView should be able to access the same data as the rest of the app, and any changes made to the task list should be reflected across all views.

It works. This took a bit of time and a bit of back and forth with ChatGPT that when it finally worked, I had almost forgotten how ugly it is.

Adding and editing tasks in Task Manager App - code generated by ChatGPT

Adding, Editing and persisting tasks work in Task Manager App - code generated by ChatGPT

There is also some rudimentary support for dark mode as well as swipe to delete.

Task Manager App supports light and dark modes - code generated by ChatGPT

Conclusion

As humans, we tend to personify many things and it is very easy to fall into this with ChatGPT. After all, I am asking questions and it is responding and it seems to be building on what has already been discussed in the chat. Although, there are responses that seem to imply it may have forgotten. I think it is better to think of ChatGPT as a type of autocomplete, although a very sophisticated version of autocomplete.

This took a bit more work than I thought, but ChatGPT arguably created the iOS app to manage tasks. I also had to debug and identify the root cause of issues and essentially solve them first and then use this knowledge to try and coax ChatGPT to give me the right solution. There are a number of things I would do differently next time. The first of which is to not use Tasks and instead perhaps call it a TODO list manager. I don’t think I would ever create a Struct or Class named Task because of the use of Tasks in Swift.

ChatGPT is great for a whole load of things, but it might be too early to get rid of all you software engineers just yet 😀. There are increasing quality levels that the code for any application needs to meet and I think ChatGPT is currently struggling with level 1 and 2. It is likely that tools like ChatGPT will get to levels 3 & 4, but I'm not sure on levels 5 & 6 - hang on to your designers 😀. It is also conceivable that in the future some Machine Learning functionality is baked into IDEs like Xcode freeing up the humans to focus on levels 5 and 6 of the applications.

Increasing Quality Levels

Code that is readable and maintainable.

Code that compiles without warnings or errors.

App that provides the required functionality.

Code that is performant.

App that looks good while providing the required functionality.

App that excites and delights the customer.

I think everyone should start using tools like ChatGPT, but don’t rely on it to get everything right or to produce the most performant code and certainly not the best-looking User Interface. Use ChatGPT to generate multiple solutions to a problem then read and study the sample code and learn from it to write your code to solve the problem. Paul Hudson has published a great video on Man VS Machine in Can ChatGPT write better SwiftUI code than you? that is well worth viewing.

To revisit the question - "Can ChatGPT create an iOS app in SwiftUI?".

My answer today is “Not Yet” and it would be interesting to revisit this again in a year.

Here is a list of all the commands in part-1 and part-2

Part 1

Create task management app in SwiftUI using MVVM design for iPhone

add a due date to the task and a task status field

Add unit tests

change task status to be one of "not started" "in progress" or "complete”

modify Task to conform to Equatable

make a task editable

Cannot convert value of type 'Binding<Date?>' to expected argument type 'Binding'

Update unit tests

Add unit tests for Task

test testTaskEquality fails because task1 is not equal to task3

test testTaskEquality still fails because the tasks have different id

Part 2

done button in ContentView does not display the edits to the tasks

EditableTaskView does not save task changes back to the ViewModel when done button in ContentView is selected

EditableTaskView saves the task changes except for the date to the ViewModel when done button in ContentView is selected. However the changes in the ViewModel are not shown in the TaskView views

Regenerate Response

Persist the list of tasks when the iOS app is closed using userdefaults

Two errorsClass 'JSONDecoder' requires that 'Task' conform to 'Decodable’

error in TaskViewModel - Return from initializer without initializing all stored properties

error in Task - Instance method 'decode(_:forKey:)' requires that 'TaskStatus' conform to 'Decodable'

problem in TaskManagerApp - a new TaskViewModel is created in .onChange(of: scenePhase)

it looks like ContentView is still creating a new instance of TaskViewModel rather than using the environmentObject one

The source code for TasksAppWithChatGpt is available on GitHub.

Can ChatGPT create an iOS app in SwiftUI - part 1

Eric Callanan — Sunday, 19 Mar 2023

Artificial Intelligence is trending at the moment with applications like DALL-E and Canva able to create images in certain styles and ChatGPT able to generate text. This article explores if ChatGPT can do more than childrens homework and see can ChatGPT create an iOS task app in SwiftUI. So I asked it to create a task manager app.

The ChatGPT site can get busy and you may frequently get a message that "ChatGPT is at capacity right now".

Related articles on ChatGPT and SwiftUI:

Can ChatGPT create an iOS app in SwiftUI - part 1

Can ChatGPT create an iOS app in SwiftUI - part 2

Create a circular slider in SwiftUI with ChatGPT

Tips on using chatGPT to generate code

Use version control and commit the code when it compiles

Compile the code after every change from chatGPT

Use 'Regenerate response' if not happy with the code generated

Feedback compile errors to chatGPT for a possible solution

Be prepared to roll back to a previous version and edit the request to chatGPT from there and try again

Ask chatGPT to create an app

It is necessary to create an account with ChatGPT and log in to start a conversation. I simply ask chatGPT to create an app in SwiftUI.

First prompt to create the app

Create task management app in SwiftUI using MVVM design for iPhone

Response from chatGPT

Sure, I can guide you on how to create a task management app in SwiftUI using the MVVM design pattern for iPhone. Here are the steps to follow:
Step 1: Create a new SwiftUI project in Xcode.
Step 2: Create a new file for the model, Task.swift.

Model

1struct Task: Identifiable {
2    var id = UUID()
3    var title: String
4    var completed: Bool = false
5}

Step 3: Create a new file for the ViewModel, TaskViewModel.swift.

ViewModel

1class TaskViewModel: ObservableObject {
2    @Published var tasks = [
3        Task(title: "Task 1"),
4        Task(title: "Task 2"),
5        Task(title: "Task 3")
6    ]
7}

Step 4: Create a new file for the View, ContentView.swift.

View

 1struct ContentView: View {
 2    @ObservedObject var viewModel = TaskViewModel()
 3    
 4    var body: some View {
 5        NavigationView {
 6            List(viewModel.tasks) { task in
 7                Text(task.title)
 8            }
 9            .navigationTitle("Tasks")
10        }
11    }
12}

Step 5: Run the app on an iPhone simulator to see the list of tasks.

Step 6: Add a button to mark a task as completed in the ContentView.

View

 1struct ContentView: View {
 2    @ObservedObject var viewModel = TaskViewModel()
 3    
 4    var body: some View {
 5        NavigationView {
 6            List(viewModel.tasks) { task in
 7                Button(action: {
 8                    if let index = self.viewModel.tasks.firstIndex(where: { $0.id == task.id }) {
 9                        self.viewModel.tasks[index].completed.toggle()
10                    }
11                }) {
12                    HStack {
13                        Image(systemName: task.completed ? "checkmark.circle.fill" : "circle")
14                        Text(task.title)
15                    }
16                }
17            }
18            .navigationTitle("Tasks")
19        }
20    }
21}

Step 7: Run the app again to see the checkmarks appearing when tasks are completed.

Step 8: Add a new task button to the ContentView.

View

 1struct ContentView: View {
 2    @ObservedObject var viewModel = TaskViewModel()
 3    
 4    var body: some View {
 5        NavigationView {
 6            List(viewModel.tasks) { task in
 7                Button(action: {
 8                    if let index = self.viewModel.tasks.firstIndex(where: { $0.id == task.id }) {
 9                        self.viewModel.tasks[index].completed.toggle()
10                    }
11                }) {
12                    HStack {
13                        Image(systemName: task.completed ? "checkmark.circle.fill" : "circle")
14                        Text(task.title)
15                    }
16                }
17            }
18            .navigationTitle("Tasks")
19            .navigationBarItems(trailing: Button(action: {
20                self.viewModel.tasks.append(Task(title: "New Task"))
21            }) {
22                Image(systemName: "plus")
23            })
24        }
25    }
26}

Step 9: Run the app again to see the new task button appearing in the navigation bar.

That's it! You have successfully created a task management app in SwiftUI using the MVVM design pattern for iPhone.

Initial task app from SwiftUI code generated by ChatGPT

Initial task app from SwiftUI code generated by ChatGPT

Add more details to a Task

Well, so far so good, but the Task model just has a title. Let's see if we can add more details to the Tasks.

Next prompt to chatGPT

add a due date to the task and a task status field

Response from chatGPT

Sure, here are the steps to add a due date and a task status field to the task management app:

Step 1: Update the Task model in Task.swift to include the due date and the task status fields.

Task.swift

1struct Task: Identifiable {
2    var id = UUID()
3    var title: String
4    var completed: Bool = false
5    var dueDate: Date? // new field for due date
6    var status: String? // new field for task status
7}

Step 2: Update the TaskViewModel class in TaskViewModel.swift to include the due date and the task status fields.

TaskViewModel.swift

1class TaskViewModel: ObservableObject {
2    @Published var tasks = [
3        Task(title: "Task 1", dueDate: Date(), status: "In progress"),
4        Task(title: "Task 2", dueDate: Date().addingTimeInterval(86400), status: "Not started"),
5        Task(title: "Task 3", dueDate: nil, status: "Complete")
6    ]
7}

Step 3: Update the ContentView to display the due date and the task status in the list.

ContentView.swift

 1struct ContentView: View {
 2    @ObservedObject var viewModel = TaskViewModel()
 3    
 4    static let taskDateFormat: DateFormatter = {
 5        let formatter = DateFormatter()
 6        formatter.dateStyle = .medium
 7        return formatter
 8    }()
 9    
10    var body: some View {
11        NavigationView {
12            List(viewModel.tasks) { task in
13                VStack(alignment: .leading) {
14                    Text(task.title)
15                    if let dueDate = task.dueDate {
16                        Text("Due date: \(dueDate, formatter: Self.taskDateFormat)")
17                            .font(.caption)
18                    }
19                    if let status = task.status {
20                        Text("Status: \(status)")
21                            .font(.caption)
22                    }
23                }
24                .foregroundColor(task.completed ? .gray : .primary)
25                .opacity(task.completed ? 0.5 : 1)
26                .onTapGesture {
27                    if let index = self.viewModel.tasks.firstIndex(where: { $0.id == task.id }) {
28                        self.viewModel.tasks[index].completed.toggle()
29                    }
30                }
31            }
32            .navigationTitle("Tasks")
33            .navigationBarItems(trailing: Button(action: {
34                self.viewModel.tasks.append(Task(title: "New Task", dueDate: Date(), status: "Not started"))
35            }) {
36                Image(systemName: "plus")
37            })
38        }
39    }
40}

Step 4: Run the app on an iPhone simulator to see the due date and the task status appearing in the list.

Step 5: Update the new task button to include the due date and the task status fields.

Step 6: Run the app again to see the new task button creating tasks with the due date and the task status fields.

That's it! You have successfully added a due date and a task status field to the task management app.

Updated tasks to include a due date and a status - code generated by ChatGPT

Updated tasks to include a due date and a status - code generated by ChatGPT

Add unit tests

Now that I have the beginings of an app, I decide to go mad and ask chatGPT to add unit tests.

Next prompt to chatGPT

Add unit tests

Response from chatGPT

Sure, adding unit tests to the task management app is a great way to ensure that the code is working as expected and to catch any issues before they reach production. Here are the steps to add unit tests to the app:

Step 1: Create a new file called TaskViewModelTests.swift in the same directory as TaskViewModel.swift.

Step 2: In TaskViewModelTests.swift, import XCTest and the app's code.

TaskViewModelTests.swift

1import XCTest
2@testable import TaskManager

Step 3: Define a class for the unit tests and a variable for the TaskViewModel.

TaskViewModelTests.swift

1class TaskViewModelTests: XCTestCase {
2    var viewModel: TaskViewModel!
3}

Step 4: Override the setUp() method to create a new instance of TaskViewModel.

TaskViewModelTests.swift

1override func setUp() {
2    viewModel = TaskViewModel()
3}

Step 5: Write a unit test for the add task functionality.

TaskViewModelTests.swift

1func testAddTask() {
2    let initialCount = viewModel.tasks.count
3    viewModel.tasks.append(Task(title: "New Task", dueDate: Date(), status: "Not started"))
4    let finalCount = viewModel.tasks.count
5    XCTAssertEqual(finalCount, initialCount + 1)
6}

Step 6: Write a unit test for the toggle completed functionality.

TaskViewModelTests.swift

1func testToggleCompleted() {
2    let task = Task(title: "Task", dueDate: Date(), status: "In progress")
3    viewModel.tasks.append(task)
4    viewModel.tasks[0].completed.toggle()
5    XCTAssertTrue(viewModel.tasks[0].completed)
6}

Step 7: Write a unit test for the due date and the task status fields.

TaskViewModelTests.swift

1func testDueDateAndStatus() {
2    let task = Task(title: "Task", dueDate: Date(), status: "In progress")
3    viewModel.tasks.append(task)
4    XCTAssertNotNil(viewModel.tasks[0].dueDate)
5    XCTAssertEqual(viewModel.tasks[0].status, "In progress")
6}

Step 8: Override the tearDown() method to set the TaskViewModel to nil.

TaskViewModelTests.swift

1override func tearDown() {
2    viewModel = nil
3}

Step 9: Run the unit tests and ensure that they all pass.

That's it! You have successfully added unit tests to the task management app. You can continue to add more unit tests as needed to ensure that the code is working as expected.

Added unit tests to Task Manager app - code generated by ChatGPT

Added unit tests to Task Manager app - code generated by ChatGPT

Change Task Status to be ENUM

The Status property in Task was created as an optional string, it would be better if this was an enum.

Next prompt to chatGPT

change task status to be one of "not started" "in progress" or "complete"

Response from chatGPT

Sure, here are the steps to change the task status to be one of "not started", "in progress", or "complete" in the task management app:

Step 1: Update the Task model in Task.swift to use an enumeration for the task status.

Task.swift

 1enum TaskStatus: String, CaseIterable {
 2    case notStarted = "Not started"
 3    case inProgress = "In progress"
 4    case complete = "Complete"
 5}
 6
 7struct Task: Identifiable {
 8    var id = UUID()
 9    var title: String
10    var completed: Bool = false
11    var dueDate: Date?
12    var status: TaskStatus = .notStarted // update status field to use enumeration
13}

Step 2: Update the TaskViewModel class in TaskViewModel.swift to use the TaskStatus enumeration and to initialize the task status field to .notStarted.

TaskViewModel.swift

1class TaskViewModel: ObservableObject {
2    @Published var tasks = [
3        Task(title: "Task 1", dueDate: Date(), status: .inProgress),
4        Task(title: "Task 2", dueDate: Date().addingTimeInterval(86400), status: .notStarted),
5        Task(title: "Task 3", dueDate: nil, status: .complete)
6    ]
7}

Step 3: Update the ContentView to use the TaskStatus enumeration and to update the task status based on user selection.

ContentView.swift

 1struct ContentView: View {
 2    @ObservedObject var viewModel = TaskViewModel()
 3    
 4    static let taskDateFormat: DateFormatter = {
 5        let formatter = DateFormatter()
 6        formatter.dateStyle = .medium
 7        return formatter
 8    }()
 9    
10    var body: some View {
11        NavigationView {
12            List(viewModel.tasks) { task in
13                VStack(alignment: .leading) {
14                    Text(task.title)
15                    if let dueDate = task.dueDate {
16                        Text("Due date: \(dueDate, formatter: Self.taskDateFormat)")
17                            .font(.caption)
18                    }
19                    Text("Status:")
20                    Picker("Task Status", selection: $viewModel.tasks[viewModel.tasks.firstIndex(of: task)!].status) {
21                        ForEach(TaskStatus.allCases, id: \.self) { status in
22                            Text(status.rawValue).tag(status)
23                        }
24                    }
25                    .pickerStyle(SegmentedPickerStyle())
26                }
27                .foregroundColor(task.completed ? .gray : .primary)
28                .opacity(task.completed ? 0.5 : 1)
29                .onTapGesture {
30                    if let index = self.viewModel.tasks.firstIndex(where: { $0.id == task.id }) {
31                        self.viewModel.tasks[index].completed.toggle()
32                    }
33                }
34            }
35            .navigationTitle("Tasks")
36            .navigationBarItems(trailing: Button(action: {
37                self.viewModel.tasks.append(Task(title: "New Task", dueDate: Date(), status: .notStarted))
38            }) {
39                Image(systemName: "plus")
40            })
41        }
42    }
43}

Step 4: Run the app on an iPhone simulator to see the updated task status options in the list and the ability to update the task status.

Step 5: Update the unit tests to ensure that the new task status enumeration is being used correctly.

That's it! You have successfully changed the task status to be one of "not started", "in progress", or "complete" in the task management app.

Next prompt to chatGPT

modify Task to conform to Equatable

Response from chatGPT

Sure, here's how you can modify the Task struct in Task.swift to conform to the Equatable protocol:

Task.swift

 1struct Task: Identifiable, Equatable {
 2    var id = UUID()
 3    var title: String
 4    var completed: Bool = false
 5    var dueDate: Date?
 6    var status: TaskStatus = .notStarted
 7    
 8    static func == (lhs: Task, rhs: Task) -> Bool {
 9        return lhs.id == rhs.id
10    }
11}

In this modified implementation, we added Equatable protocol conformance to the Task struct by adding the protocol name after Identifiable, separated by a comma. Then we implemented the == operator function, which compares two Task instances for equality based on their id properties.

Added due date and status to tasks - code generated by ChatGPT

Added due date and status to tasks - code generated by ChatGPT

Allow Tasks to be changed

The app can now display a list of tasks with a title, due Date and a status and new tasks can be added to the list. The next step is to make the Tasks editable.

Next prompt to chatGPT

make a task editable

Response from chatGPT

Sure, here's how you can make a task editable in the task management app:

Step 1: Add an isEditing property to the TaskViewModel class in TaskViewModel.swift.

TaskViewModel.swift

1class TaskViewModel: ObservableObject {
2    @Published var tasks = [
3        Task(title: "Task 1", dueDate: Date(), status: .inProgress),
4        Task(title: "Task 2", dueDate: Date().addingTimeInterval(86400), status: .notStarted),
5        Task(title: "Task 3", dueDate: nil, status: .complete)
6    ]
7    @Published var isEditing = false // add isEditing property
8}

Step 2: Add an Edit button to the ContentView that toggles the isEditing property.

ContentView.swift

 1struct ContentView: View {
 2    @ObservedObject var viewModel = TaskViewModel()
 3    
 4    static let taskDateFormat: DateFormatter = {
 5        let formatter = DateFormatter()
 6        formatter.dateStyle = .medium
 7        return formatter
 8    }()
 9    
10    var body: some View {
11        NavigationView {
12            List {
13                ForEach(viewModel.tasks) { task in
14                    if viewModel.isEditing {
15                        EditableTaskView(task: $viewModel.tasks[viewModel.tasks.firstIndex(of: task)!])
16                    } else {
17                        TaskView(task: task)
18                    }
19                }
20                .onDelete { indexSet in
21                    self.viewModel.tasks.remove(atOffsets: indexSet)
22                }
23            }
24            .navigationTitle("Tasks")
25            .navigationBarItems(
26                trailing: HStack {
27                    if viewModel.isEditing {
28                        Button("Done") {
29                            self.viewModel.isEditing.toggle()
30                        }
31                    } else {
32                        Button(action: {
33                            self.viewModel.tasks.append(Task(title: "New Task", dueDate: Date(), status: .notStarted))
34                        }) {
35                            Image(systemName: "plus")
36                        }
37                        Button("Edit") {
38                            self.viewModel.isEditing.toggle()
39                        }
40                    }
41                }
42            )
43        }
44    }
45}

TaskView.swift

 1struct TaskView: View {
 2    let task: Task
 3    
 4    var body: some View {
 5        VStack(alignment: .leading) {
 6            Text(task.title)
 7            if let dueDate = task.dueDate {
 8                Text("Due date: \(dueDate, formatter: ContentView.taskDateFormat)")
 9                    .font(.caption)
10            }
11            Text("Status: \(task.status.rawValue)")
12        }
13        .foregroundColor(task.completed ? .gray : .primary)
14        .opacity(task.completed ? 0.5 : 1)
15    }
16}

EditableTaskView.swift

 1struct EditableTaskView: View {
 2    @Binding var task: Task
 3    
 4    var body: some View {
 5        VStack(alignment: .leading) {
 6            TextField("Title", text: $task.title)
 7            if let dueDate = task.dueDate {
 8                DatePicker("Due date", selection: $task.dueDate, displayedComponents: .date)
 9            }
10            Picker("Task Status", selection: $task.status) {
11                ForEach(TaskStatus.allCases, id: \.self) { status in
12                    Text(status.rawValue).tag(status)
13                }
14            }
15            .pickerStyle(SegmentedPickerStyle())
16        }
17        .foregroundColor(task.completed ? .gray : .primary)
18        .opacity(task.completed ? 0.5 : 1)
19    }
20}

Step 3: Create two new views, TaskView and EditableTaskView, that will display the task information in read-only and editable mode, respectively. In EditableTaskView, use a Binding to allow the task to be edited and modified in place.

Step 4: Update the ContentView to display the EditableTaskView when the isEditing property is true

Error in the EditableTaskView on initial code to make a task editable - code generated by ChatGPT

Error in the EditableTaskView on initial code to make a task editable - code generated by ChatGPT

Fix Data Binding Error in EditableTaskView

The code generated to make the Task editable does not compile. There are a number of options with charGPT, the easiest of which is to just regenerate the code from the previous request. Alternatively, we can prompt chatGPT with the error message to see if it can provide a solution.

Next prompt to chatGPT

Cannot convert value of type 'Binding<Date?>' to expected argument type
'Binding<Date>'

Response from chatGPT

The error message "Cannot convert value of type 'Binding<Date?>' to expected argument type 'Binding'" occurs because a Binding<Date?> cannot be directly assigned to a Binding.

Here's how you can fix the error in the EditableTaskView:

Step 1: Declare a new Date property in EditableTaskView that will be used to store the current value of the due date.

EditableTaskView.swift

1struct EditableTaskView: View {
2    @Binding var task: Task
3    @State private var dueDate: Date? // Add new property
4    
5    var body: some View {
6        // ...
7    }
8}

Step 2: In the initializer of EditableTaskView, assign the value of the task's due date to the dueDate property.

EditableTaskView.swift

 1struct EditableTaskView: View {
 2    @Binding var task: Task
 3    @State private var dueDate: Date?
 4    
 5    init(task: Binding<Task>) {
 6        _task = task
 7        _dueDate = State(initialValue: task.wrappedValue.dueDate) // Assign initial value to dueDate
 8    }
 9    
10    var body: some View {
11        // ...
12    }
13}

Step 3: Use the dueDate property to create a Binding in the DatePicker.

EditableTaskView.swift

 1struct EditableTaskView: View {
 2    @Binding var task: Task
 3    @State private var dueDate: Date?
 4    
 5    init(task: Binding<Task>) {
 6        _task = task
 7        _dueDate = State(initialValue: task.wrappedValue.dueDate)
 8    }
 9    
10    var body: some View {
11        VStack(alignment: .leading) {
12            TextField("Title", text: $task.title)
13            if let dueDate = dueDate {
14                DatePicker("Due date", selection: Binding<Date>(
15                    get: { dueDate },
16                    set: { newValue in self.dueDate = newValue }
17                ), displayedComponents: .date)
18            }
19            Picker("Task Status", selection: $task.status) {
20                ForEach(TaskStatus.allCases, id: \.self) { status in
21                    Text(status.rawValue).tag(status)
22                }
23            }
24            .pickerStyle(SegmentedPickerStyle())
25        }
26        .foregroundColor(task.completed ? .gray : .primary)
27        .opacity(task.completed ? 0.5 : 1)
28    }
29}

With these changes, the dueDate property is used as an intermediary between the Binding<Date?> and the Binding, allowing you to modify the due date value in place.

SwiftUI App with an Editable list of Tasks - code generated by ChatGPT

SwiftUI App with an Editable list of Tasks - code generated by ChatGPT

Task App broke

Now that there have been a number of changes to tasks, I asked chatGPT to update the unit tests.

Update unit tests

I will not detail the back and forth here as there were unit tests added that did not match the app. The resoltion of these compile errors led to modifying the structs and classes such as the addition of a TaskListViewModel and then some confucion on what was in a TaskViewModel and TaskListViewModel. I eventually got the app to compile again, but the ContentView had changed too much and the app had lost some functionality. In addition clicking on a Task seemed to navigate to a subview withthe same list of tasks and son on recursively. I did not spend too much time debugging and instead chose to roll back the code to when it was last working.

Task App broke after resolving errors on unit tests on ViewModel - code generated by ChatGPT

Task App broke after resolving errors on unit tests on ViewModel - code generated by ChatGPT

Add unit tests to Task

It is possible to "Regenerate response" for every response in ChatGPT with an option to toggle between the different responses. It is also possible to go back to a previous request and edit it and then save and submit. This removes the previous response and any subsequent request and responses.

After getting so lost with resolving compile errors with the updated unit tests and the introduction of new ViewModels and ultimately loosing functionality in the app I went back to the request to update the unit tests. This time, I specified to just add unit tests for Task. I also rolled back the code from git. Even adding these unit tests took a couple of attempts.

Next prompt to chatGPT

Add unit tests for Task

Response from chatGPT

Sure! Here's an example of how you could write some unit tests for the Task struct.

TaskTests.swift

 1import XCTest
 2@testable import TaskManager
 3
 4class TaskTests: XCTestCase {
 5    
 6    // Test task creation
 7    func testTaskCreation() {
 8        let title = "Test Task"
 9        let dueDate = Date()
10        let status: TaskStatus = .notStarted
11        
12        let task = Task(title: title, dueDate: dueDate, status: status)
13        
14        XCTAssertEqual(task.title, title)
15        XCTAssertEqual(task.dueDate, dueDate)
16        XCTAssertEqual(task.status, status)
17        XCTAssertFalse(task.completed)
18    }
19    
20    // Test task completion
21    func testTaskCompletion() {
22        var task = Task(title: "Test Task", dueDate: nil, status: .notStarted)
23        
24        XCTAssertFalse(task.completed)
25        
26        task.completed = true
27        
28        XCTAssertTrue(task.completed)
29    }
30    
31    // Test task status updates
32    func testTaskStatusUpdates() {
33        var task = Task(title: "Test Task", dueDate: nil, status: .notStarted)
34        
35        XCTAssertEqual(task.status, .notStarted)
36        
37        task.status = .inProgress
38        
39        XCTAssertEqual(task.status, .inProgress)
40        
41        task.status = .complete
42        
43        XCTAssertEqual(task.status, .complete)
44    }
45    
46    // Test task equality
47    func testTaskEquality() {
48        let task1 = Task(title: "Task 1", dueDate: nil, status: .notStarted)
49        let task2 = Task(title: "Task 2", dueDate: nil, status: .notStarted)
50        let task3 = Task(title: "Task 1", dueDate: nil, status: .notStarted)
51        
52        XCTAssertNotEqual(task1, task2)
53        XCTAssertEqual(task1, task3)
54    }
55}

In this example, we have four test methods that cover some basic functionality of the Task struct:

testTaskCreation: tests that a task is created with the expected properties and that completed is initially set to false.

testTaskCompletion: tests that completed can be set to true and that the value is stored correctly.

testTaskStatusUpdates: tests that the status property can be updated to each of the three possible values (notStarted, inProgress, and complete) and that the value is stored correctly.

testTaskEquality: tests the implementation of Equatable by creating three tasks with different titles but the same values for dueDate, status, and completed. The test asserts that the two tasks with the same title are considered equal, while the one with a different title is not.

Of course, you could write additional tests to cover other scenarios or edge cases, but this should give you a good starting point.

ChatGPT allows you to Regenerate response with a mechanism to toggle between the responses

ChatGPT allows you to Regenerate response with a mechanism to toggle between the responses

Fix Failing unit test

One of the unit tests fails. Let's feed that back to ChatGPT to see what it recommends.

Next prompt to chatGPT

test testTaskEquality fails because task1 is not equal to task3

Response from chatGPT

I apologize for the mistake in my previous response. You are correct that the testTaskEquality test case should fail because the Task instances with different titles should not be considered equal. Here's the corrected test case:

TaskTests.swift

1func testTaskEquality() {
2    let task1 = Task(title: "Task 1", dueDate: nil, status: .notStarted)
3    let task2 = Task(title: "Task 2", dueDate: nil, status: .notStarted)
4    let task3 = Task(title: "Task 1", dueDate: nil, status: .notStarted)
5    
6    XCTAssertNotEqual(task1, task2)
7    XCTAssertNotEqual(task1, task2)
8    XCTAssertEqual(task1, task3)
9}

In this corrected test case, we expect task1 and task3 to be equal because they have the same values for dueDate, status, and completed, even though their title properties are different. The assertion XCTAssertNotEqual(task1, task2) ensures that tasks with different titles are not considered equal, while the assertion XCTAssertEqual(task1, task3) ensures that tasks with the same values for the other properties are considered equal, regardless of their titles.

Unit Test is still failing.

Next prompt to chatGPT

test testTaskEquality still fails because the tasks have different id

Response from chatGPT

I apologize again for the mistake in my previous response. You are correct that the Task instances in the test cases have different id properties, which will cause the equality check to fail even if all other properties are equal.

To fix the testTaskEquality test case, you can create the Task instances with explicit id values that are the same for the two tasks with the same title:

TaskTests.swift

 1func testTaskEquality() {
 2    let id1 = UUID()
 3    let id2 = UUID()
 4    
 5    let task1 = Task(id: id1, title: "Task 1", dueDate: nil, status: .notStarted)
 6    let task2 = Task(id: id2, title: "Task 2", dueDate: nil, status: .notStarted)
 7    let task3 = Task(id: id1, title: "Task 1", dueDate: nil, status: .notStarted)
 8    
 9    XCTAssertNotEqual(task1, task2)
10    XCTAssertNotEqual(task2, task3)
11    XCTAssertEqual(task1, task3)
12}

In this version of the test case, we create two UUIDs (id1 and id2) and use id1 for both task1 and task3, so they will have the same id value. We also modify the assertions to use XCTAssertNotEqual for both task1 and task2 and XCTAssertEqual for task1 and task3, to ensure that tasks are only considered equal if they have the same id and all other properties are equal.

Unit tests on Task struct passing - code generated by ChatGPT

Unit tests on Task struct passing - code generated by ChatGPT

Editing tasks does not work

The App is now stable and it displays a list of tasks. Functionality like swipe to delete works as well as adding new tasks. However, editing the tasks appears to work until the done button is selected. Selecting edit again does show the previous edits, but these are not persisted back to the model.

I'll continue this in the next article.

Edits to the Tasks are not shown in the task list - code generated by ChatGPT

Edits to the Tasks are not shown in the task list - code generated by ChatGPT

Conclusion

I was pleasantly surprised by how much code chatGPT can generate. ChatGPT or other artificial intelligence tools are not likely to replace developers in the near future. However, I think a lot of work can be done by combining the artificial intelligence in a tool like chatGPT with the human ability to problem solve and design.

I think everyone should have a go at generating something with chatGPT. Perhaps this is the next version of auto complete, but it seems so much more as it is generating text or code and can be used to help solve technical problems

It is likely that we will get to the stage where there are those who use and work with Artificial Intelligence and those who don't and the advantage will be with those who embrace its use and learn to work with it. Of course, there are still a number of open questions with regard to copyright infringements and the law has not yet caught up all the technology we use. Is using code from chatGPT any different than searching for code on the Internet or GitHub and using that to help develop an application?

Working with chatGPT is very exciting and frightening at the same time. It has certainly given me pause to writing technical articles on solving issues that chatGPT could just spit out the answer for you whenever you need it. Although, the answers at the moment are not always right.

To answer the question "Can ChatGPT create an iOS app in SwiftUI?"

Yes and No

Yes chatGPT can generate code to create an App.
No because the user experience of using the App will not be good and the code may not work.

I would say currently that using chatGPT to help you write an app takes more time that writing the code yourself. As other people have stated chatGPT will give an answer with confidence, even when that answer is incorrect.

I am curious to continue working with chatGPT to further develop this TaskManager app. First to see how chatGPT suggests resolving the editing issue and then to persist the task data when the app is closed.

Source code for TasksAppWithChatGpt is available on GitHub.

How to cancel a background task in Swift

Eric Callanan — Sunday, 29 Jan 2023

The async/await syntax, introduced in Swift 5.5, allows a readable way to write asynchronous code. Asynchronous programming can improve performance of an app, but it is important to cancel unneeded tasks to ensure unwanted background tasks do not interfere with the app. This article demonstrates how to cancel a task explicitly and shows how the child tasks are automatically cancelled.

The code builds on the AsyncLetApp initiated in Use async let to run background tasks in parallel in Swift.

Why cancel a background tasks

Interaction with a view may trigger a background task to run and further interaction may make the initial request obsolete and trigger a subsequent background task to run. Aside from a waste of resources, not cancelling the initial task may result in intermittent and unexpected behaviour in your app.

A cancel button is added to the View with the action to call cancel in the ViewModel. Some logging is added to the ViewModel to print out when the file download is incremented and when the file isDownloading property is set to false. It can be seen that, after the download is cancelled, the task continues and eventually sets the isDownloading property to false. This can cause a problem in the UI if a download is cancelled and a subsequent download is started quickly. The isDownloading property from the first task is set to false with the effect of stopping the second download.

View

 1struct NaiveCancelView: View {
 2    @ObservedObject private var dataFiles: DataFileViewModel5
 3    @State var fileCount = 0
 4    
 5    init() {
 6        dataFiles = DataFileViewModel5()
 7    }
 8    
 9    var body: some View {
10        ScrollView {
11            VStack {
12                TitleView(title: ["Naive Cancel"])
13                
14                HStack {
15                    Button("Download All") {
16                        Task {
17                            let num = await dataFiles.downloadFile()
18                            fileCount += num
19                        }
20                    }
21                    .buttonStyle(BlueButtonStyle())
22                .disabled(dataFiles.file.isDownloading)
23                    Button("Cancel") {
24                        dataFiles.cancel()
25                    }
26                    .buttonStyle(BlueButtonStyle())
27                    .disabled(!dataFiles.file.isDownloading)
28                }
29                
30                Text("Files Downloaded: \(fileCount)")
31                
32                HStack(spacing: 10) {
33                    Text("File 1:")
34                    ProgressView(value: dataFiles.file.progress)
35                        .frame(width: 180)
36                    Text("\((dataFiles.file.progress * 100), specifier: "%0.0F")%")
37                    
38                    ZStack {
39                        Color.clear
40                            .frame(width: 30, height: 30)
41                        if dataFiles.file.isDownloading {
42                            ProgressView()
43                                .progressViewStyle(CircularProgressViewStyle(tint: .blue))
44                        }
45                    }
46                }
47                .padding()
48
49                .onDisappear {
50                    dataFiles.cancel()
51                }
52                
53                Spacer().frame(height: 200)
54                
55                Button("Reset") {
56                    dataFiles.reset()
57                }
58                .buttonStyle(BlueButtonStyle())
59                
60                Spacer()
61            }
62            .padding()
63        }
64    }
65}

ViewModel

 1class DataFileViewModel5: ObservableObject {
 2    @Published private(set) var file: DataFile
 3    
 4    init() {
 5        self.file = DataFile(id: 1, fileSize: 10)
 6    }
 7    
 8    func downloadFile() async -> Int {
 9        await MainActor.run {
10            file.isDownloading = true
11        }
12        
13        for _ in 0..<file.fileSize {
14            await MainActor.run {
15                guard file.isDownloading else { return }
16                file.increment()
17                print("  --   Downloading file - \(file.progress * 100) %")
18            }
19            usleep(300000)
20        }
21        
22        await MainActor.run {
23            file.isDownloading = false
24            print(" ***** File : \(file.id) setting isDownloading to FALSE")
25        }
26        
27        return 1
28    }
29    
30    func cancel() {
31        file.isDownloading = false
32        self.file = DataFile(id: 1, fileSize: 10)
33    }
34        
35    func reset() {
36        self.file = DataFile(id: 1, fileSize: 10)
37    }
38}

The second download task is stopped by the completion of the first background task

The second download task is stopped by the completion of the first background task

Use Cancel Flag

There are a number of approaches to cancel work in a background task. One mechanism is to add a status flag to the object with the asynchronous task and to monitor this flag while the task is running. There are no changes to the View required, the cancel button still calls the Cancel function in the ViewModel.

The changes to the ViewModel include the addition of a cancelFlag boolean property, which has to be marked with MainActor as it needs to be updated on the main UI thread. The loop that is simulating a file download is updated from a for loop to a while loop dependent on two conditions:

the cancel flag is false
the file is downloading

This fixes the problem, but it seems excessive to have an extra flag for cancelling a download.

View

 1struct CancelFlagView: View {
 2    @ObservedObject private var dataFiles: DataFileViewModel6
 3    @State var fileCount = 0
 4
 5    init() {
 6        dataFiles = DataFileViewModel6()
 7    }
 8    
 9    var body: some View {
10        ScrollView {
11            VStack {
12                TitleView(title: ["Use Cancel Flag"])
13                
14                HStack {
15                    Button("Download All") {
16                        Task {
17                            let num = await dataFiles.downloadFile()
18                            fileCount += num
19                        }
20                    }
21                    .buttonStyle(BlueButtonStyle())
22                .disabled(dataFiles.file.isDownloading)
23                    Button("Cancel") {
24                        dataFiles.cancel()
25                    }
26                    .buttonStyle(BlueButtonStyle())
27                    .disabled(!dataFiles.file.isDownloading)
28                }
29                
30                Text("Files Downloaded: \(fileCount)")
31                
32                HStack(spacing: 10) {
33                    Text("File 1:")
34                    ProgressView(value: dataFiles.file.progress)
35                        .frame(width: 180)
36                    Text("\((dataFiles.file.progress * 100), specifier: "%0.0F")%")
37                    
38                    ZStack {
39                        Color.clear
40                            .frame(width: 30, height: 30)
41                        if dataFiles.file.isDownloading {
42                            ProgressView()
43                                .progressViewStyle(CircularProgressViewStyle(tint: .blue))
44                        }
45                    }
46                }
47                .padding()
48                
49                .onDisappear {
50                    dataFiles.cancel()
51                }
52
53                Spacer().frame(height: 200)
54                
55                Button("Reset") {
56                    dataFiles.reset()
57                }
58                .buttonStyle(BlueButtonStyle())
59                
60                Spacer()
61            }
62            .padding()
63        }
64    }
65}

ViewModel

 1class DataFileViewModel6: ObservableObject {
 2    @Published private(set) var file: DataFile
 3    
 4    @MainActor var cancelFlag = false
 5    
 6    init() {
 7        self.file = DataFile(id: 1, fileSize: 10)
 8    }
 9    
10    func downloadFile() async -> Int {
11        await MainActor.run {
12            file.isDownloading = true
13        }
14        
15        while await !cancelFlag, file.isDownloading {
16            await MainActor.run {
17                print("  --   Downloading file - \(file.progress * 100) %")
18                file.increment()
19            }
20            usleep(300000)
21        }
22        
23        await MainActor.run {
24            file.isDownloading = false
25            print(" ***** File : \(file.id) setting isDownloading to FALSE")
26        }
27        
28        return 1
29    }
30  
31    @MainActor
32    func cancel() {
33        self.cancelFlag = true
34        print(" ***** File : \(file.id) setting cancelFlag to TRUE")
35        self.reset()
36    }
37        
38    @MainActor
39    func reset() {
40        self.file = DataFile(id: 1, fileSize: 10)
41        self.cancelFlag = false
42    }
43}

Use of cancel flag in ViewModel to end the background loop

Use of cancel flag in ViewModel to end the background loop

Cancel the task instance - Task.checkCancellation()

A more elegant solution is to create a State property for the Task and assign the task to this property in the view for the Download button action. The Cancel button can then cancel this task. That sounds simple, right! Well, there's a little more to do because, as the documentation says:

Tasks include a shared mechanism for indicating cancellation, but not a shared implementation for how to handle cancellation.

This is because how a task is cancelled will vary depending on what the task is doing.

In this example, the downloadFile function in the ViewModel is changed to use checkCancellation within the loop of the download. This checks for cancellation and will throw an error if the task has been cancelled. When this error is thrown, the isDownloading flag can be set to false and optionally, the ViewModel can be reset.

In this case, the Cancel Flag and all the associated code can be removed completely from the ViewModel.

View

 1struct CancelTaskView: View {
 2    @ObservedObject private var dataFiles: DataFileViewModel7
 3    @State var fileCount = 0
 4    
 5    @State var fileDownloadTask: Task<Void, Error>?
 6    
 7    init() {
 8        dataFiles = DataFileViewModel7()
 9    }
10    
11    var body: some View {
12        ScrollView {
13            VStack {
14                TitleView(title: ["Cancel Task", "", "<checkCancellation()>"])
15                
16                HStack {
17                    Button("Download All") {
18                        fileDownloadTask = Task {
19                            let num = await dataFiles.downloadFile()
20                            fileCount += num
21                        }
22                    }
23                    .buttonStyle(BlueButtonStyle())
24                    .disabled(dataFiles.file.isDownloading)
25                    Button("Cancel") {
26                        fileDownloadTask?.cancel()
27                    }
28                    .buttonStyle(BlueButtonStyle())
29                    .disabled(!dataFiles.file.isDownloading)
30                }
31                
32                Text("Files Downloaded: \(fileCount)")
33                
34                HStack(spacing: 10) {
35                    Text("File 1:")
36                    ProgressView(value: dataFiles.file.progress)
37                        .frame(width: 180)
38                    Text("\((dataFiles.file.progress * 100), specifier: "%0.0F")%")
39                    
40                    ZStack {
41                        Color.clear
42                            .frame(width: 30, height: 30)
43                        if dataFiles.file.isDownloading {
44                            ProgressView()
45                                .progressViewStyle(CircularProgressViewStyle(tint: .blue))
46                        }
47                    }
48                }
49                .padding()
50                
51                .onDisappear {
52                    fileDownloadTask?.cancel()
53                    dataFiles.reset()
54                }
55                
56                Spacer().frame(height: 200)
57                
58                Button("Reset") {
59                    fileDownloadTask?.cancel()
60                    dataFiles.reset()
61                }
62                .buttonStyle(BlueButtonStyle())
63                
64                Spacer()
65            }
66            .padding()
67        }
68    }
69}

ViewModel

 1class DataFileViewModel7: ObservableObject {
 2    @Published private(set) var file: DataFile
 3    
 4    init() {
 5        self.file = DataFile(id: 1, fileSize: 10)
 6    }
 7    
 8    func downloadFile() async  -> Int {
 9        await MainActor.run {
10            file.isDownloading = true
11        }
12        
13        while file.isDownloading {
14            do {
15                try await MainActor.run {
16                    try Task.checkCancellation()
17                    
18                    print("  --   Downloading file - \(file.progress * 100) %")
19
20                    file.increment()
21                }
22                usleep(300000)
23            } catch {
24                print(" *************** Catch - The task has been cancelled")
25                // Set the isDownloading flag to false
26                await MainActor.run {
27                    file.isDownloading = false
28                    // reset()
29                }
30            }
31        }
32        
33        await MainActor.run {
34            file.isDownloading = false
35            print(" ***** File : \(file.id) setting isDownloading to FALSE")
36        }
37        
38        return 1
39    }
40        
41    @MainActor
42    func reset() {
43        self.file = DataFile(id: 1, fileSize: 10)
44    }
45}

Cancel a Task instance in SwiftUI

Cancel a Task instance in SwiftUI

Task cancellation propagates to child tasks - Task.isCancelled

An alternative to raising an exception with checkCancellation is to use isCancelled to see if a task has been cancelled or not.

This approach still uses a State property for the Task. This is assigned to the downloadFiles function in the download button and the task is cancelled with the cancel button in the view.

The difference is in the ViewModel where the while loop includes a check for !Task.isCancelled so that the download continues if it has not been cancelled. This approach can be used for the single file download or as the code below demonstrates for the multiple file download.

Note that the Task that is cancelled is the main downloadFiles, which has multiple async calls to download multiple files. When the main task is cancelled, the cancellation propagates to all of the child tasks automatically in Swift.

View

 1struct CancelTaskMultipleView: View {
 2    @ObservedObject private var dataFiles: DataFileViewModel8
 3    
 4    @State var fileDownloadTask: Task<Void, Error>?
 5    
 6    init() {
 7        dataFiles = DataFileViewModel8()
 8    }
 9    
10    var body: some View {
11        ScrollView {
12            VStack {
13                TitleView(title: ["Cancel Task", "", "<Task.isCancelled>"])
14                
15                HStack {
16                    Button("Download All") {
17                        fileDownloadTask = Task {
18                            await dataFiles.downloadFiles()
19                        }
20                    }
21                    .buttonStyle(BlueButtonStyle())
22                    .disabled(dataFiles.isDownloading)
23                    
24                    Button("Cancel") {
25                        fileDownloadTask?.cancel()
26                    }
27                    .buttonStyle(BlueButtonStyle())
28                    .disabled(!dataFiles.isDownloading)
29                }
30                
31                Text("Files Downloaded: \(dataFiles.fileCount)")
32                
33                ForEach(dataFiles.files) { file in
34                    HStack(spacing: 10) {
35                        Text("File \(file.id):")
36                        ProgressView(value: file.progress)
37                            .frame(width: 180)
38                        Text("\((file.progress * 100), specifier: "%0.0F")%")
39                        
40                        ZStack {
41                            Color.clear
42                                .frame(width: 30, height: 30)
43                            if file.isDownloading {
44                                ProgressView()
45                                    .progressViewStyle(CircularProgressViewStyle(tint: .blue))
46                            }
47                        }
48                    }
49                }
50                .padding()
51                
52                .onDisappear {
53                    fileDownloadTask?.cancel()
54                    dataFiles.reset()
55                }
56                
57                Spacer().frame(height: 150)
58                
59                Button("Reset") {
60                    fileDownloadTask?.cancel()
61                    dataFiles.reset()
62                }
63                .buttonStyle(BlueButtonStyle())
64                
65                Spacer()
66            }
67            .padding()
68        }
69    }
70}

ViewModel

 1class DataFileViewModel8: ObservableObject {
 2    @Published private(set) var files: [DataFile]
 3    @Published private(set) var fileCount = 0
 4    
 5    init() {
 6        files = [
 7            DataFile(id: 1, fileSize: 10),
 8            DataFile(id: 2, fileSize: 20),
 9            DataFile(id: 3, fileSize: 5)
10        ]
11    }
12    
13    var isDownloading : Bool {
14        files.filter { $0.isDownloading }.count > 0
15    }
16    
17    func downloadFiles() async {
18        async let num1 = await downloadFile(0)
19        async let num2 = await downloadFile(1)
20        async let num3 = await downloadFile(2)
21        let (result1, result2, result3) = await (num1, num2, num3)
22        await MainActor.run {
23            fileCount = result1 + result2 + result3
24        }
25    }
26    
27    private func downloadFile(_ index: Array<DataFile>.Index) async -> Int {
28        await MainActor.run {
29            files[index].isDownloading = true
30        }
31        
32        while files[index].isDownloading, !Task.isCancelled {
33            await MainActor.run {
34                print("  --   Downloading file \(files[index].id) - \(files[index].progress * 100) %")
35                files[index].increment()
36            }
37            usleep(300000)
38        }
39        
40        await MainActor.run {
41            files[index].isDownloading = false
42            print(" ***** File : \(files[index].id) setting isDownloading to FALSE")
43        }
44        return 1
45    }
46    
47    @MainActor
48    func reset() {
49        files = [
50            DataFile(id: 1, fileSize: 10),
51            DataFile(id: 2, fileSize: 20),
52            DataFile(id: 3, fileSize: 5)
53        ]
54    }
55}

Cancelling a task instance cancels child tasks in SwiftUI

Cancelling a task instance cancels child tasks in SwiftUI

Cancelling and resuming background tasks in SwiftUI

Cancelling and resuming background tasks in SwiftUI

Conclusion

In Asynchronous programming, it is important to stop any unneeded background tasks to save resources and avoid any unwanted side-effects from background tasks interfering with the App. The Swift Async framework provides a number of ways to indicate that a task has been cancelled, but it is up to the implementer of the code in the task to respond appropriately when the task has been cancelled. Once a task has been cancelled, it cannot be uncancelled. One way to check if a task has been cancelled is to use checkCancellation, which will throw an error. Another is to simply use isCancelled as aboolean flag to see if the task has been cancelled.

Source code for AsyncLetApp is available on GitHub.

Use async let to run background tasks in parallel in Swift

Eric Callanan — Sunday, 15 Jan 2023

The async/await syntax was introduced in Swift 5.5 with Meet async/await in Swift in WWDC 2021. It is a more readable way to write asynchronous code and is easier to understand than dispatch queues and callback functions. The async/await syntax is similar to those used in other programming languages like C# or JavaScript. Use of "async let" is used to run multiple background tasks in parallel and wait for their combined results.

Swift Asynchronous Programming is a method of writing code that allows certain tasks to run concurrently, rather than sequentially. This can improve performance of an app by allowing it to perform multiple tasks at the same time, but more importantly, it can be used to ensure the UI is responsive to user input while tasks are performed on background threads.

Long running activity blocks the UI

In a synchronous program, the code runs in a linear, top-to-bottom fashion. The program waits for the current line to complete before moving on to the next one. This can cause problems in a user interface (UI) context, because if a long-running task is executed synchronously, the program will block and the UI will become unresponsive until the task is completed.

The following code simulates a long running task such as downloading a file in a synchronous way with the result that thu UI becomes unresponsive until the task is complete. This demonstrates an unacceptable user experience as the starting point.

Model

 1struct DataFile : Identifiable, Equatable {
 2    var id: Int
 3    var fileSize: Int
 4    var downloadedSize = 0
 5    var isDownloading = false
 6    
 7    init(id: Int, fileSize: Int) {
 8        self.id = id
 9        self.fileSize = fileSize
10    }
11    
12    var progress: Double {
13        return Double(self.downloadedSize) / Double(self.fileSize)
14    }
15    
16    mutating func increment() {
17        if downloadedSize < fileSize {
18            downloadedSize += 1
19        }
20    }
21}

ViewModel

 1class DataFileViewModel: ObservableObject {
 2    @Published private(set) var file: DataFile
 3    
 4    init() {
 5        self.file = DataFile(id: 1, fileSize: 10)
 6    }
 7    
 8    func downloadFile() {
 9        file.isDownloading = true
10
11        for _ in 0..<file.fileSize {
12            file.increment()
13            usleep(300000)
14        }
15
16        file.isDownloading = false
17    }
18    
19    func reset() {
20        self.file = DataFile(id: 1, fileSize: 10)
21    }
22}

View

 1struct TestView1: View {
 2    @ObservedObject private var dataFiles: DataFileViewModel
 3    
 4    init() {
 5        dataFiles = DataFileViewModel()
 6    }
 7    
 8    var body: some View {
 9        VStack {
10            TitleView(title: ["Synchronous"])
11            
12            Button("Download All") {
13                dataFiles.downloadFile()
14            }
15            .buttonStyle(BlueButtonStyle())
16            .disabled(dataFiles.file.isDownloading)
17            
18            HStack(spacing: 10) {
19                Text("File 1:")
20                ProgressView(value: dataFiles.file.progress)
21                    .frame(width: 180)
22                Text("\((dataFiles.file.progress * 100), specifier: "%0.0F")%")
23
24                ZStack {
25                    Color.clear
26                        .frame(width: 30, height: 30)
27                    if dataFiles.file.isDownloading {
28                        ProgressView()
29                            .progressViewStyle(CircularProgressViewStyle(tint: .blue))
30                    }
31                }
32            }
33            .padding()
34            
35            Spacer().frame(height: 200)
36
37            Button("Reset") {
38                dataFiles.reset()
39            }
40            .buttonStyle(BlueButtonStyle())
41
42            Spacer()
43        }
44        .padding()
45    }
46}

Simulated downloading a file synchronously - no UI update

Simulated downloading a file synchronously - no UI update

Use async/await to perform task in background

The code in the ViewModel is changed tom make the downloadFile method asynchronous. Note that as the DataFile model is being observed by the view, any changes to the model need to be performed on the UI thread. This is done using MainActor queue by wrapping any model updates with MainActor.run.

The view is updated to wrap the asynchronous call to downloadFile in a Task. This runs the download in the background while the UI remains responsive and displays progress.

ViewModel

 1class DataFileViewModel2: ObservableObject {
 2    @Published private(set) var file: DataFile
 3    
 4    init() {
 5        self.file = DataFile(id: 1, fileSize: 10)
 6    }
 7    
 8    func downloadFile() async -> Int {
 9        await MainActor.run {
10            file.isDownloading = true
11        }
12        
13        for _ in 0..<file.fileSize {
14            await MainActor.run {
15                file.increment()
16            }
17            usleep(300000)
18        }
19        
20        await MainActor.run {
21            file.isDownloading = false
22        }
23        
24        return 1
25    }
26    
27    func reset() {
28        self.file = DataFile(id: 1, fileSize: 10)
29    }
30}

View

 1struct TestView2: View {
 2    @ObservedObject private var dataFiles: DataFileViewModel2
 3    @State var fileCount = 0
 4    
 5    init() {
 6        dataFiles = DataFileViewModel2()
 7    }
 8    
 9    var body: some View {
10        VStack {
11            TitleView(title: ["Asynchronous"])
12            
13            Button("Download All") {
14                Task {
15                    let num = await dataFiles.downloadFile()
16                    fileCount += num
17                }
18            }
19            .buttonStyle(BlueButtonStyle())
20            .disabled(dataFiles.file.isDownloading)
21            
22            Text("Files Downloaded: \(fileCount)")
23            
24            HStack(spacing: 10) {
25                Text("File 1:")
26                ProgressView(value: dataFiles.file.progress)
27                    .frame(width: 180)
28                Text("\((dataFiles.file.progress * 100), specifier: "%0.0F")%")
29                
30                ZStack {
31                    Color.clear
32                        .frame(width: 30, height: 30)
33                    if dataFiles.file.isDownloading {
34                        ProgressView()
35                            .progressViewStyle(CircularProgressViewStyle(tint: .blue))
36                    }
37                }
38            }
39            .padding()
40            
41            Spacer().frame(height: 200)
42            
43            Button("Reset") {
44                dataFiles.reset()
45            }
46            .buttonStyle(BlueButtonStyle())
47            
48            Spacer()
49        }
50        .padding()
51    }
52}

Use async await to simulate downloading a file while UI is updated

Use async await to simulate downloading a file while UI is updated

Performing multiple tasks in the background

Now that we have one file downloading in the background and the UI displaying progress, let's change it to multiple files. The ViewModel is changed to hold an array of DataFiles rather than a single one. A downloadFiles method is added to loop through all the files and download each one.

The view is updated to bind to the array of DataFiles and display the download progress for each one. The Download button is bound to the async downloadFiles inside a Task.

ViewModel

 1class DataFileViewModel3: ObservableObject {
 2    @Published private(set) var files: [DataFile]
 3    @Published private(set) var fileCount = 0
 4    
 5    init() {
 6        files = [
 7            DataFile(id: 1, fileSize: 10),
 8            DataFile(id: 2, fileSize: 20),
 9            DataFile(id: 3, fileSize: 5)
10        ]
11    }
12    
13    var isDownloading : Bool {
14        files.filter { $0.isDownloading }.count > 0
15    }
16    
17    func downloadFiles() async {
18        for index in files.indices {
19            let num = await downloadFile(index)
20            await MainActor.run {
21                fileCount += num
22            }
23        }
24    }
25    
26    private func downloadFile(_ index: Array<DataFile>.Index) async -> Int {
27        await MainActor.run {
28            files[index].isDownloading = true
29        }
30        
31        for _ in 0..<files[index].fileSize {
32            await MainActor.run {
33                files[index].increment()
34            }
35            usleep(300000)
36        }
37        await MainActor.run {
38            files[index].isDownloading = false
39        }
40        return 1
41    }
42    
43    func reset() {
44        files = [
45            DataFile(id: 1, fileSize: 10),
46            DataFile(id: 2, fileSize: 20),
47            DataFile(id: 3, fileSize: 5)
48        ]
49    }
50}

View

 1struct TestView3: View {
 2    @ObservedObject private var dataFiles: DataFileViewModel3
 3    
 4    init() {
 5        dataFiles = DataFileViewModel3()
 6    }
 7    
 8    var body: some View {
 9        VStack {
10            TitleView(title: ["Asynchronous", "(multiple Files)"])
11            
12            Button("Download All") {
13                Task {
14                    await dataFiles.downloadFiles()
15                }
16            }
17            .buttonStyle(BlueButtonStyle())
18            .disabled(dataFiles.isDownloading)
19            
20            Text("Files Downloaded: \(dataFiles.fileCount)")
21            
22            ForEach(dataFiles.files) { file in
23                HStack(spacing: 10) {
24                    Text("File \(file.id):")
25                    ProgressView(value: file.progress)
26                        .frame(width: 180)
27                    Text("\((file.progress * 100), specifier: "%0.0F")%")
28                    
29                    ZStack {
30                        Color.clear
31                            .frame(width: 30, height: 30)
32                        if file.isDownloading {
33                            ProgressView()
34                                .progressViewStyle(CircularProgressViewStyle(tint: .blue))
35                        }
36                    }
37                }
38            }
39            .padding()
40            
41            Spacer().frame(height: 150)
42            
43            Button("Reset") {
44                dataFiles.reset()
45            }
46            .buttonStyle(BlueButtonStyle())
47            
48            Spacer()
49        }
50        .padding()
51    }
52}

Use async await to simulate downloading multiple files sequentially

Use async await to simulate downloading multiple files sequentially

Use "async let" to simulate downloading multiple files in parallel

The code above can be improved to perform the multiple downloads in parallel as each task is independent of the other tasks. In Swift concurrency this is achieved using async let, which sets a variable immediately with a promise, allowing the code to execute the next line of code. The code then awaits these promises for the final result to be complete.

async/await

1    func downloadFiles() async {
2        for index in files.indices {
3            let num = await downloadFile(index)
4            await MainActor.run {
5                fileCount += num
6            }
7        }
8    }

async let

 1    func downloadFiles() async {
 2        async let num1 = await downloadFile(0)
 3        async let num2 = await downloadFile(1)
 4        async let num3 = await downloadFile(2)
 5        
 6        let (result1, result2, result3) = await (num1, num2, num3)
 7        await MainActor.run {
 8            fileCount = result1 + result2 + result3
 9        }
10    }

ViewModel

 1class DataFileViewModel4: ObservableObject {
 2    @Published private(set) var files: [DataFile]
 3    @Published private(set) var fileCount = 0
 4    
 5    init() {
 6        files = [
 7            DataFile(id: 1, fileSize: 10),
 8            DataFile(id: 2, fileSize: 20),
 9            DataFile(id: 3, fileSize: 5)
10        ]
11    }
12    
13    var isDownloading : Bool {
14        files.filter { $0.isDownloading }.count > 0
15    }
16    
17    func downloadFiles() async {
18        async let num1 = await downloadFile(0)
19        async let num2 = await downloadFile(1)
20        async let num3 = await downloadFile(2)
21        
22        let (result1, result2, result3) = await (num1, num2, num3)
23        await MainActor.run {
24            fileCount = result1 + result2 + result3
25        }
26    }
27    
28    private func downloadFile(_ index: Array<DataFile>.Index) async -> Int {
29        await MainActor.run {
30            files[index].isDownloading = true
31        }
32        
33        for _ in 0..<files[index].fileSize {
34            await MainActor.run {
35                files[index].increment()
36            }
37            usleep(300000)
38        }
39        await MainActor.run {
40            files[index].isDownloading = false
41        }
42        return 1
43    }
44    
45    
46    func reset() {
47        files = [
48            DataFile(id: 1, fileSize: 10),
49            DataFile(id: 2, fileSize: 20),
50            DataFile(id: 3, fileSize: 5)
51        ]
52    }
53}

View

 1struct TestView4: View {
 2    @ObservedObject private var dataFiles: DataFileViewModel4
 3    
 4    init() {
 5        dataFiles = DataFileViewModel4()
 6    }
 7    
 8    var body: some View {
 9        VStack {
10            TitleView(title: ["Parallel", "(multiple Files)"])
11            
12            Button("Download All") {
13                Task {
14                    await dataFiles.downloadFiles()
15                }
16            }
17            .buttonStyle(BlueButtonStyle())
18            .disabled(dataFiles.isDownloading)
19            
20            Text("Files Downloaded: \(dataFiles.fileCount)")
21            
22            ForEach(dataFiles.files) { file in
23                HStack(spacing: 10) {
24                    Text("File \(file.id):")
25                    ProgressView(value: file.progress)
26                        .frame(width: 180)
27                    Text("\((file.progress * 100), specifier: "%0.0F")%")
28                    
29                    ZStack {
30                        Color.clear
31                            .frame(width: 30, height: 30)
32                        if file.isDownloading {
33                            ProgressView()
34                                .progressViewStyle(CircularProgressViewStyle(tint: .blue))
35                        }
36                    }
37                }
38            }
39            .padding()
40            
41            Spacer().frame(height: 150)
42            
43            Button("Reset") {
44                dataFiles.reset()
45            }
46            .buttonStyle(BlueButtonStyle())
47            
48            Spacer()
49        }
50        .padding()
51    }
52}

Use async let to simulate downloading multiple files in parallel

Use "async let" to simulate downloading multiple files in parallel

Use async let to simulate downloading multiple files in parallel

Use "async let" to simulate downloading multiple files in parallel

Conclusion

It is important to perform long-running tasks in the background and keep the UI responsive. async/await provides a clean mechanism to perform asynchronous tasks. There are times when a method is calling multiple methods in the background and the default is to make these calls in sequence. async let returns immediately allowing the code to proceed to the next call and then all the returned objects can be awaited together. This allows multiple background tasks to be performed in parallel.

Source code for AsyncLetApp is available on GitHub.