ProgressView updating on multiple steps of computation - swiftui

Question

I'm coding an app targeted at iOS but would be nice if it would still work (as is the case now) with iPadOS and macOS. This is a scientific app that performs matrices computations using LAPACK. A typical "step" of computation takes 1 to 5 seconds and I want the user to be able to run multiple computations with different parameters by clicking a single time on a button. For example, with an electric motor, the user clicks the button and it virtually performs the action of turning the motor, time step after time step until it reaches a final value. With each step, the “single step” computation returns a value, and the “multiple step” general computation gathers all these single step values in a list, the aim being to make a graph of these results.
So, my issue is making a progress bar so that the user knows where he is with the computation he issued. Using a for loop, I can run the multistep but it won’t refresh the ProgressView until the multistep computation is over. Thus, I decided to try DispatchQueue.global().async{}, in which I update the progress of my computation. It seems to work on the fact of refreshing the ProgressView but I get warnings that tell me I’m doing it the wrong way:
[SwiftUI] Publishing changes from background threads is not allowed;
make sure to publish values from the main thread (via operators like
receive(on:)) on model updates.
I do not know how to publish on ProgressView, also because all the examples I come across on the Internet show how to update ProgressView with a timer, and that is not what I want to do, I want each computation to be achieved, send ProgressView the fact that it can update, and continue with my computation.
Also, what I did does not update correctly the final values. As the computation is asynchronous, the multistep function finishes instantaneously, showing a value of 0.0 while when the tasks finishes, the final value should be 187500037500.0. I show you an example code with these values, it’s a dummy and I put a huge for loop to slow down the code and ressemble a computation so you can see the update of the ProgressView.
import SwiftUI
class Params: ObservableObject {
/// This is a class where I store all my user parameters
#Published var progress = 0.0
#Published var value = 0.0
}
struct ContentView: View {
#StateObject var params = Params()
#FocusState private var isFocused: Bool
var body: some View {
NavigationView {
List {
Section("Electromagnetics") {
NavigationLink {
Form {
ViewMAG_MultiStep(isFocused: _isFocused)
}
.toolbar {
ToolbarItemGroup(placement: .keyboard) {
Spacer()
Button("Done") {
isFocused = false
}
}
}
} label: {
Text("Multi-step")
}
}
}
.navigationTitle("FErez")
}
.environmentObject(params)
}
}
struct ViewMAG_MultiStep: View {
#FocusState var isFocused: Bool
#EnvironmentObject var p: Params
#State private var showResults = false
#State private var induction = 0.0
var body: some View{
List{
Button("Compute") {
induction = calcMultiStep(p: p)
showResults.toggle()
}
.sheet(isPresented: $showResults) {
Text("\(induction)")
ProgressView("Progress...", value: p.progress, total: 100)
}
}
.navigationTitle("Multi-step")
}
}
func calcSingleStep(p: Params) -> Double {
/// Long computation, can be 1 to 5 seconds.
var induction = p.value
for i in 0...5000000 {
induction += Double(i) * 0.001
}
return induction
}
func calcMultiStep(p: Params) -> Double{
/// Usually having around 20 steps, can be up to 400.
var induction = 0.0
DispatchQueue.global().async {
for i in 0...5 {
induction += Double(i) * calcSingleStep(p: p)
p.progress += 10.0
}
print("Final value of induction: \(induction)")
}
return induction
}
struct ContentView_Previews: PreviewProvider {
static var previews: some View {
ContentView()
}
}

Answer 1

You have used the wrong thread, you should update the UI only on the main thread:
DispatchQueue.main.async { //main thread not global.
Please note: You should move those functions to your View struct or to a shared class, as using global functions does not align with best practices.